ב-Java מערך הוא מבנה נתונים ליניארי חשוב המאפשר לנו לאחסן מספר ערכים מאותו סוג.

• מערכים ב-Java הם אובייקטים כמו כל שאר האובייקטים במערכים של Java יורשים באופן מרומז מהמחלקה java.lang.Object. זה מאפשר לך להפעיל מתודות המוגדרות ב-Object (כגון toString() equals() ו-hashCode()).
• למערכים יש מאפיין אורך מובנה המספק את מספר האלמנטים במערך

public class Geeks {  public static void main(String[] args)  {  // initializing array  int[] arr = {40 55 63 17 22};  // size of array  int n = arr.length;  // traversing array  for (int i = 0; i < n; i++)  System.out.print(arr[i] + ' ');  } } 

40 55 63 17 22 

תכונות עיקריות של מערכים

• אחסן פרימיטיבים וחפצים: מערכי Java יכולים להכיל גם סוגים פרימיטיביים (כמו int char boolean וכו') וגם אובייקטים (כמו String Integer וכו')
• הקצאת זיכרון רציפה כאשר אנו משתמשים במערכים של טיפוסים פרימיטיביים האלמנטים מאוחסנים במקומות רציפים. עבור סוגים לא פרימיטיביים הפניות של פריטים מאוחסנות במיקומים רציפים.
• אינדקס מבוסס אפס: האלמנט הראשון של המערך נמצא באינדקס 0.
• אורך קבוע: לאחר יצירת מערך הגודל שלו קבוע; אנחנו לא יכולים לשנות את זה.

תפעול בסיסי על מערכים ב-Java

1. הכרזה על מערך

הצורה הכללית של הצהרת מערך היא 

// שיטה 1:
int arr[];

// שיטה 2:
int[] arr;

סוג האלמנט קובע את סוג הנתונים של כל אלמנט המרכיב את המערך. כמו מערך של מספרים שלמים אנו יכולים גם ליצור מערך של סוגי נתונים פרימיטיביים אחרים כמו char float double וכו' או סוגי נתונים המוגדרים על ידי משתמש (אובייקטים של מחלקה).

פֶּתֶק: זה פשוט איך אנחנו יכולים ליצור משתנה מערך לא קיים מערך בפועל. זה רק אומר למהדר שהמשתנה הזה (int Array) יחזיק מערך מסוג מספר שלם.

גיגה-בייט מול מגה-בייט

2. אתחול מערך ב-Java

כאשר מכריזים על מערך נוצרת רק הפניה של מערך. אנו משתמשים בחדש כדי להקצות מערך בגודל נתון.

int arr[] = new int[גודל];

• הצהרת מערך היא בדרך כלל סטטית, אך אם הגודל אינו מוגדר, המערך הוא בגודל דינמי.
• זיכרון עבור מערכים מוקצה תמיד באופן דינמי (בקטע ערימה) ב-Java. זה שונה מ-C/C++ שבו ניתן להקצות זיכרון סטטית או דינמית.
• האלמנטים במערך שהוקצו על ידי new יאותחו אוטומטית לאפס (עבור סוגים מספריים), false (עבור בוליאני) או null (עבור סוגי התייחסות).

מערך ליטרל ב-Java

במצב בו גודל המערך והמשתנים של המערך כבר ידועים במילולי מערך ניתן להשתמש. 

// הכרזה על מערך מילולי
int[] arr = new int[]{ 12345678910 };

• אורכו של מערך זה קובע את אורך המערך שנוצר.
• אין צורך לכתוב את החלק החדש int[] בגרסאות האחרונות של Java.

3. שנה אלמנט מערך

כדי לשנות אלמנט, הקצה ערך חדש לאינדקס ספציפי. האינדקס מתחיל ב-0 ומסתיים ב-(גודל מערך כולל)-1.

// שינוי האלמנט הראשון ל-90
arr[0] = 90;

4. אורך מערך

נוכל לקבל את האורך של מערך באמצעות המאפיין length:

// קבלת אורך המערך
int n = arr.length;

5. גישה ועדכון של כל רכיבי המערך

• ניתן לגשת לכל האלמנטים של המערך באמצעות Java for Loop.
• כל אלמנט במערך נגיש דרך האינדקס שלו.

תוכנית Java להמחשת יצירת מערך של מספרים שלמים מכניסה כמה ערכים למערך ומדפיסה כל ערך לפלט סטנדרטי

class Geeks {  public static void main(String[] args)  {  // declares an Array of integers.  int[] arr;  // allocating memory for 5 integers.  arr = new int[5];  // initialize the elements of the array  // first to last(fifth) element  arr[0] = 2;  arr[1] = 4;  arr[2] = 8;  arr[3] = 12;  arr[4] = 16;  // accessing the elements of the specified array  for (int i = 0; i < arr.length; i++)  System.out.println('Element at index ' +  i + ' : ' + arr[i]);  } } 

Element at index 0 : 2 Element at index 1 : 4 Element at index 2 : 8 Element at index 3 : 12 Element at index 4 : 16 

מערכי אובייקטים ב-Java

מערך של אובייקטים נוצר כמו מערך של פריטי נתונים מסוג פרימיטיבי

דוּגמָה : כאן אנחנו לוקחים כיתת תלמידים ויוצרים מערך של Student עם חמישה אובייקטים של Student המאוחסנים במערך. יש להפעיל את אובייקטי הסטודנטים באמצעות הבנאי של כיתת הסטודנטים ויש להקצות את ההפניות שלהם לרכיבי המערך.

class Student {  public int roll_no;  public String name;    Student(int roll_no String name){  this.roll_no = roll_no;  this.name = name;  } } public class Geeks {  public static void main(String[] args){    // declares an Array of Student  Student[] arr;  // allocating memory for 5 objects of type Student.  arr = new Student[5];  // initialize the elements of the array  arr[0] = new Student(1 'aman');  arr[1] = new Student(2 'vaibhav');  arr[2] = new Student(3 'shikar');  arr[3] = new Student(4 'dharmesh');  arr[4] = new Student(5 'mohit');  // accessing the elements of the specified array  for (int i = 0; i < arr.length; i++)  System.out.println('Element at ' + i + ' : { '  + arr[i].roll_no + ' '  + arr[i].name+' }');  } } 

Element at 0 : { 1 aman } Element at 1 : { 2 vaibhav } Element at 2 : { 3 shikar } Element at 3 : { 4 dharmesh } Element at 4 : { 5 mohit } 

מה קורה אם ננסה לגשת לאלמנטים מחוץ לגודל המערך?

JVM זורק את ArrayIndexOutOfBoundsException כדי לציין שהגישה למערך באמצעות אינדקס לא חוקי. האינדקס הוא שלילי או גדול או שווה לגודלו של מערך.

הקוד שלהלן מראה מה קורה אם ננסה לגשת לאלמנטים מחוץ לגודל המערך:

public class Geeks {  public static void main(String[] args)  {  int[] arr = new int[4];  arr[0] = 10;  arr[1] = 20;  arr[2] = 30;  arr[3] = 40;  System.out.println(  'Trying to access element outside the size of array');  System.out.println(arr[5]);  } } 

תְפוּקָה:

העברת מערכים לשיטות

כמו משתנים אנחנו יכולים גם להעביר מערכים לשיטות. לדוגמה, התוכנית להלן מעבירה את המערך לסכום השיטה כדי לחשב את סכום ערכי המערך.

דוּגמָה:

public class Geeks {  // Driver method  public static void main(String args[])  {  int arr[] = { 3 1 2 5 4 };  // passing array to method m1  sum(arr);  }  public static void sum(int[] arr)  {  // getting sum of array values  int sum = 0;  for (int i = 0; i < arr.length; i++)  sum += arr[i];  System.out.println('sum of array values : ' + sum);  } } 

sum of array values : 15 

הֶסבֵּר

• תוכנית Java זו מדגימה כיצד להעביר מערך לשיטה.
• מערך שלמים arr מוכרז ומאוחל בשיטה הראשית.
• שיטת sum() נקראת עם arr כארגומנט.
• בתוך שיטת sum() כל רכיבי המערך מתווספים באמצעות לולאת for.
• לאחר מכן הסכום הסופי מודפס לקונסולה.

החזרת מערכים משיטות

כרגיל שיטה יכולה גם להחזיר מערך. לדוגמה התוכנית להלן מחזירה מערך משיטה m1. 

דוּגמָה:

class Geeks {  // Driver method  public static void main(String args[])  {  int arr[] = m1();  for (int i = 0; i < arr.length; i++)  System.out.print(arr[i] + ' ');  }  public static int[] m1()  {  // returning array  return new int[] { 1 2 3 };  } } 

1 2 3 

היתרונות של מערכי Java

• גישה יעילה: הגישה לאלמנט לפי האינדקס שלו היא מהירה ובעלת מורכבות זמן קבועה O(1).
• ניהול זיכרון: למערכים יש גודל קבוע שהופך את ניהול הזיכרון לפשוט וצפוי.
• ארגון נתונים: מערכים עוזרים לארגן נתונים בצורה מובנית ומקלה על ניהול אלמנטים קשורים.

החסרונות של מערכי Java

• גודל קבוע: לאחר יצירת מערך לא ניתן לשנות את הגודל שלו, מה שעלול להוביל לבזבוז זיכרון אם הגודל מוערך יתר על המידה או אחסון לא מספיק אם מעריכים פחות.
• סוג הומוגניות: מערכים יכולים לאחסן רק אלמנטים מאותו סוג נתונים אשר עשויים לדרוש טיפול נוסף עבור סוגי נתונים מעורבים.
• הכנסה ומחיקה: הכנסה או מחיקה של אלמנטים במיוחד באמצע מערך עלולה לעלות ביוקר מכיוון שהיא עשויה לדרוש הסטה של ​​אלמנטים.

פוסטים קשורים

• מערך משונן ב-Java
• עבור כל לולאה ב-Java
• כיתת מערכים ב-Java