כיצד לאתחל מערך בג'אווה



מערך Java

כיצד לאתחל מערך בג'אווה

מערכים ב- java הם מבנה הנתונים הנפוץ ביותר המאחסן מספר ערכים מאותו סוג נתונים בסדר רציף. למערך אורך קבוע והמדד מתחיל מ- 0 ל- n-1 כאשר n הוא אורכו של מערך. אנו יכולים להשתמש בכיתת מערכים ב- Java לאחסון כל סוג של ערך כמו מחרוזת, מספר שלם, תווים, בתים ואפילו אובייקטים המוגדרים על ידי המשתמש. נלמד כיצד לאתחל מערך בג'אווה?

להלן הייצוג הדיאגרמטי של מערך חד-ממדי של מספרים שלמים עם 11 אלמנטים.

מערכים בג'אווה

תכונות מערכי Java

כיצד להכריז על מערך בג'אווה?

הצהרת מערכי Java

ניתן להכריז על מערך בדרכים הבאות. הצהרת מערך מכילה 2 חלקים, הראשון הוא סוג הנתונים של האלמנטים שעלינו לאחסן במערך (כמו int, String, וכו ') ואחריו שם המערך. סוגריים [] מסמנים כי מדובר במערך. כאשר אנו מצהירים על מערך, הוא רק אומר למהדר שהמשתנה הוא מערך ואינו יוצר למעשה מערך.

סוג נתונים [] arrayName; (אוֹ)

סוג נתונים [] arrayName; (אוֹ)

מערך נתונים מסוג שם []; -> בדרך כלל אנו לא מעדיפים להשתמש בשיטה זו למרות שהיא תקפה.

דוגמה להצהרת מערך

int[] arrNumbers;
String[] arrNames;
float[] arrValues;
boolean[] arrBoolean;
char[] arrLetters;
byte[] arrBytes;
double[] arrWeight;

כיצד ליצור מערך ב- Java?

מערך מחרוזות בג'אווה

אנו יוצרים מערך באמצעות ה- חדש מַפעִיל. בכך אנו מציינים את גודל המערך ב- [] המציין את כמות הזיכרון הנדרשת לאחסון משתנה המערך.

arrname = סוג נתונים חדש [גודל];

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

int[] arrNumbers = new int[5];
String[] arrNames = new String[2];

כיצד לאתחל מערך ב- Java?

איך מייצרים מערך?

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

//Method 1
int[] arrNumbers = {1,2,3};

//Method 2
int[] arrNumbers = new int[3];
arrNumbers[0] = 1;
arrNumbers[1] = 2;
arrNumbers[2] = 3;

גישה לאלמנטים מערכים ב- Java

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

דוגמה: יצירה, אתחול וגישה למרכיבי מערך

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

public class ArrayDemo1 {

  public static void main(String[] args) {
    String[] arrMonths = {"May","June","July"};
    System.out.println("Length of array is: " + arrMonths.length);
    for(int i=0;i<arrMonths.length;i++)
    {
      System.out.println(arrMonths[i]); 
    }

  }

}
Output:
Length of array is: 3
May
June
July

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

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

public class ArrayDemo2 {

  public static void main(String[] args) {
    int[] numbers = new int[5];
    numbers[0] = 100;
    numbers[1] = 101;
    numbers[2] = 103;
    numbers[3] = 104;
    numbers[4] = 105;
    
    for(int i: numbers)
    {
      System.out.println(i);
    }

  }

}
Output:
100
101
103
104
105

סוגי מערכים בג'אווה

ישנם שני סוגים של מערכים בג'אווה:

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

מערכים רב מימדיים בג'אווה

מערכים רב מימדיים יכולים להכיל מספר שורות ועמודות. האינדקס ב [] הראשון מייצג שורות והשני [] מייצג עמודות.

למשל: int [] [] a = int int [2] [3]

פירוש הדבר שהמערך מכיל 2 שורות ו -3 עמודות. להלן הייצוג הדיאגרמטי של מערך רב מימדי

מערכים בג'אווה

דוגמה ליצירת מערכים רב ממדיים של מיתרים

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

public class ArrayMulti {

  public static void main(String[] args) {
    String[][] arrNames = {{"John","Jacob"},{"Thomas","Martin"}};
    System.out.println(arrNames[0][0] + " " + arrNames[0][1]);
    System.out.println(arrNames[1][0] + " " + arrNames[1][1]);

  }

}
Output:
John Jacob 
Thomas Martin

דוגמה למערך דו-ממדי של מספרים שלמים

כאן אנו יוצרים מערך דו מימדי של מספרים שלמים הכוללים 2 שורות ו -2 עמודות. אנו מקצים את הערכים לאלמנטים של מערך זה לולאה. הראשון לולאה מציין שורות והשני לולאה מציין עמודות.

public class ArrayMulti {

  public static void main(String[] args) {
    //Declare and create multidimensional array
    int[][] arrnum = new int[2][3];
    for(int i=0;i<2;i++) {
      for(int j=0;j<3;j++) {
        //Assign values to array elements
        arrnum[i][j] = i+1;
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }

  }

}
Output:
1 1 1 
2 2 2 

מערכים משוננים בג'אווה

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

אתחול מערך המשונן

במהלך יצירת המערך, אנו מציינים את מספר השורות. בדוגמה זו זהו 2. בשני המשפטים הבאים, עבור כל מערך שורות, אנו מציינים את מספר העמודות. כאן, בשורה הראשונה יש 2 עמודות ובשורה השנייה יש 1 עמודות.

int[][] arrnum = new int[2][];
arrnum[0] = new int[3];
arrnum[1] = new int[4];

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

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arrnum = new int[2][];
    arrnum[0] = new int[3];
    arrnum[1] = new int[4];

    int val=1;
    //Assign values
    for(int i=0;i<arrnum.length;i++) {
      for(int j=0;j<arrnum[i].length;j++) {
        arrnum[i][j] = val;
      }
    }
    
    //Print the values
    for(int i=0;i<arrnum.length;i++)
    {
      for(int j=0;j<arrnum[i].length;j++)
      {
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }
  }

}
Output:
1 1 1 
1 1 1 1 

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

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arr = {{4,5,6},{1,2},{7,9,8}};
    for(int i=0;i<3;i++)
    {
      for(int j=0;j<arr[i].length;j++) {
        System.out.print(arr[i][j] + " ");
      }
      System.out.println();
    }
  }
}
Output:
4 5 6 
1 2 
7 9 8 

שיטות מערך ג'אווה

להלן השיטות הישירות הנתמכות על ידי Arrays ב- Java

שִׁיטָהתיאור
שיבוט בטל ()משכפל את ערכי המערך הקיימים שבהם לא מועתקים הפניות
בוליאני שווה (אובייקט 0)בודק אם אובייקט אחר שווה לאובייקט הנוכחי
Class getClass ()מחזיר את שם הכיתה
מחרוזת toString ()מחזיר ייצוג מחרוזת של האובייקט
אורך int ()מחזיר את אורך המערך

חריגים במערך Java

מערכים ב ג'אווה זורק החריג להלן:

  • ArrayIndexOutOfBoundsException: זה קורה כאשר ערך האינדקס שאנו מציינים גדול מאורך המערך או כשהוא שלילי. זה קורה בעיקר בעת הקצאת ערך או גישה לאלמנטים של מערך.

העתק מערך

אנו יכולים להעתיק אלמנטים ממערך אחד למשנהו באמצעות מערך ההעתקה של המחלקה System.

העתק תחביר מערך

arraycopy חלל ציבורי (אובייקט src, int srcPos, אובייקט dest, int destPos, int אורך);

אובייקט מערך src-source להעתקה ממנו

srcPos - מיקום התחלתי במערך המקור

יעד - אובייקט מערך היעד להעתקה

destPos - מיקום התחלתי במערך היעד

אורך - מספר רכיבי המערך להעתקה

דוגמה להעתקת מערך

בדוגמה שלהלן אנו מעתיקים 4 אלמנטים ממערך המקור למערך היעד. מכאן שהפלט מודפס "ג'אווה" "

public class ArrayCopy {

  public static void main(String[] args) {
    char[] a = {'d','l','h','y','j','a','v','a','g','r','t'};
    char[] b = new char[4];
    
    System.arraycopy(a, 4, b, 0, 4);
    System.out.println(String.valueOf(b));

  }

}
Output:
java

העבר מערך לשיטה

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

public class ArrayDemo3 {

  public static void main(String[] args) {
    int[] num = {5,7,3,2,8};
    add(num);

  }
  
  public static void add(int[] num) {
    int sum = 0;
    for(int i=0;i<num.length;i++) {
      sum = sum + num[i];
    }
    System.out.println("Sum of array elements is : " + sum);
  }

}
Output:
Sum of array elements is : 25

החזר מערך משיטה

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

public class ArrayDemo4 {

  public static void main(String[] args) {
    String[] arr = getArrayValues();
    for(String cities:arr) {
      System.out.println(cities);
    }
      

  }
  
  public static String[] getArrayValues() {
    String[] arrCities = {"Chennai","Bangalore","Delhi"};
    return arrCities;
  }

}
Output:
Chennai
Bangalore
Delhi

מניפולציות במערך

מערכים ב Java שייכים לחבילת java.util. ישנן מספר פעולות הנתמכות על ידי מחלקת java.util.Array כאמור להלן:

  • אנו יכולים להשתמש בשיטת copyOfRange של מחלקת מערך כדי להעתיק מגוון אלמנטים ממערך אחד למשנהו
  • חפש במערך ערך ספציפי על סמך אינדקס (חיפוש בינארי)
  • השווה למערכים כדי לבדוק שוויון בשיטה שווה
  • השתמש בשיטת המילוי כדי למלא מערך כדי להציב ערך ספציפי באינדקס
  • מיון מערך בשיטת המיון

יצירת מערך באמצעות אובייקט מוגדר על ידי המשתמש

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

public class ArrayDemo5 {

  public static void main(String[] args) {
    Student[] s = new Student[2];
    s[0] = new Student(111,"Ajit");
    s[1] = new Student(112,"Biju");
  }

}
 class Student{
  public int rollno;
  public String name;
  public Student(int rno,String n) {
    rollno = rno;
    name = n;
  }
}

סיכום

הדרכה זו מספקת תיאור מפורט של Class Arrays ב- Java, סוגי מערכים ב- Java, הצהרה, יצירה וניתוח של מערכים עם איורים שונים.

התייחסות