ב-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