ווי צו יניטיאַליזירן אַ מענגע אין דזשאַוואַ  



מענגע ז'אבא

ווי צו יניטיאַליזירן אַ מענגע אין דזשאַוואַ

Arrays אין Java זענען די מערסט וויידלי געוויינט דאַטן סטרוקטור וואָס סטאָרז קייפל וואַלועס פון די זעלבע דאַטן טיפּ אין סאַקווענטשאַל סדר. די מענגע האט אַ פאַרפעסטיקט לענג און דער אינדעקס סטאַרץ פון 0 צו n-1, וווּ n איז די לענג פון אַ מענגע. מיר קענען נוצן ערייז קלאַס אין Java צו קראָם קיין טיפּ פון ווערט ווי סטרינג, ינטאַדזשער, כאַראַקטער, ביטע און אפילו באַניצער-דיפיינד אַבדזשעקץ. מיר וועלן לערנען ווי צו ינישאַלייז אַ מענגע אין Java?

ונטער דער דיאַגראַמאַטיק פאַרטרעטונג פון אַ איין-דימענשאַנאַל מענגע פון ​​ינטאַדזשערז מיט 11 עלעמענטן.

ערייז אין דזשאַוואַ

טיש פון קאָנטענץ

Java Arrays פֿעיִקייטן  

  • די מענגע האט אַ פאַרפעסטיקט גרייס און קענען ניט זיין טשיינדזשד
  • זינט די מענגע איז אינדעקס-באזירט, עס איז גרינג צו אַקסעס טראַפ עלעמענטן
  • אַללאָקאַטעס קעסיידערדיק זיקאָרן פֿאַר מענגע עלעמענטן.
  • קענען קראָם ביידע פּרימיטיוו און ניט-פּרימיטיוו דאַטן וואַלועס
זע אויך
ווי צו צוריקקומען אַ מענגע אין Java

ווי צו דערקלערן אַן אַררייַ אין Java?  

Java Arrays דעקלאַראַציע

אַ מענגע קענען זיין דערקלערט אויף די אונטן וועגן. ערי דעקלאַראַציע כּולל 2 פּאַרץ, דער ערשטער איז די דאַטיי טיפּ פון די עלעמענטן וואָס מיר דאַרפֿן צו קראָם אין אַ מענגע (ווי ינט, סטרינג, עטק) און נאכגעגאנגען דורך די נאָמען פון די מענגע. [] בראַקאַץ אָנווייַזן אַז עס איז אַ מענגע. ווען מיר דערקלערן אַ מענגע, עס פּונקט דערציילט די קאַמפּיילער אַז די בייַטעוודיק איז אַ מענגע און טוט נישט אַקשלי מאַכן אַ מענגע.

דאַטייטיפּע [] אַרייַנאַמע; (אדער)

דאַטייטיפּע [] אַרייַנאַמע; (אדער)

דאַטייטיפּע מענגע נאָמען []; -> נאָרמאַללי מיר טאָן ניט בעסער וועלן צו נוצן דעם אופֿן כאָטש עס איז גילטיק.

בייַשפּיל פון מענגע דעקלאַראַציע

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

ווי אַזוי צו שאַפֿן אַ עריי אין Java?  

שטריקל עריי אין Java

מיר שאַפֿן אַ מענגע מיט די נייַ אָפּעראַטאָר. אין דעם, מיר ספּעציפיצירן די גרייס פון אַ מענגע אין [] וואָס דינאָוץ די נומער פון זכּרון פארלאנגט צו קראָם די מענגע בייַטעוודיק.

אַררנאַמע = נייַ דאַטייטיפּע [גרייס];

מיר קענען אויך דערקלערן און שאַפֿן אַ מענגע אין אַ איין דערקלערונג ווי אונטן. דער ערשטער סטאַטעמענט קריייץ אַ ינטאַדזשער מענגע מיט די נומער נומער 5. די רגע קריייץ אַ שטריקל מענגע מיט די נאָמען פון גרייס 2

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

ווי צו ינישאַלייז אַ מענגע אין Java?  

ווי צו ינסטאַנטירן אַ מענגע?

ערייז יניטיאַליזאַטיאָן אָדער ינסטאַנטיאַטיאָן מיטל צושיקן וואַלועס צו אַ מענגע באזירט אויף מענגע גרייס. מיר קענען אויך מאַכן און ינסטאַלירן (ינסטאַנטיאַטע) אַ מענגע צוזאַמען (אָפּשיקן צו מעטאָד 1 ווייטער). אין דעם פאַל, די נומער פון עלעמענטן דינייץ די לענג אָדער גרייס פון אַ מענגע. אין מעטאָד 2, מיר באַשטימען וואַלועס סעפּעראַטלי צו יעדער עלעמענט. זינט די מענגע אינדעקס סטאַרץ מיט 0 און מענגע גרייס דאָ איז 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

טייפּס פון ערייז אין Java  

עס זענען 2 טייפּס פון ערייז אין Java:

  • איין דימענשאַנאַל מענגע - דאָס כּולל בלויז 1 רודערן און 1 זייַל. אַלע די אויבן ביישפילן געהערן צו אַ איין דימענשאַנאַל מענגע
  • מולטידימענסיאָנאַל מענגע - דעם כּולל קייפל ראָוז און קייפל שפאלטן. אין אנדערע ווערטער, עס איז אַ מענגע פון ​​ערייז וואָס אַלע ראָוז האָבן די זעלבע נומער פון שפאלטן. למשל: 2 * 2 מאַטריץ
  • דזשאַגגעד מענגע - יעדער רודערן כּולל אַ אַנדערש נומער פון שפאלטן

מולטידימענסיאָנאַל ערייז אין ז'אבא

מולטידימענסיאָנאַל ערייז קענען האָבן קייפל ראָוז און שפאלטן. דער אינדעקס אין דער ערשטער [] רעפּראַזענץ ראָוז און די רגע [] רעפּראַזענץ שפאלטן.

למשל: int [] [] a = new 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-דימענשאַנאַל מענגע פון ​​ינטאַדזשערז מיט 2 ראָוז און 3 שפאלטן. מיר באַשטימען די וואַלועס צו די מענגע עלעמענטן ין פֿאַר שלייף. די 1 פֿאַר שלייף דינאָוץ ראָוז און 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 ד מענגע.

זע אויך
פֿאָדעם אין Java

יניטיאַליזאַטיאָן פון Jagged Array

בעשאַס די שאַפונג פון מענגע מיר ספּעציפיצירן די נומער פון ראָוז. אין דעם בייַשפּיל, עס איז 2. אין די ווייַטער 2 סטייטמאַנץ, פֿאַר יעדער רודערן מענגע, מיר ספּעציפיצירן די נומער פון שפאלטן. דאָ, 1 רודערן האט 3 שפאלטן און 2 רודערן האט 4 שפאלטן.

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 

Java Array מעטהאָדס  

ונטער זענען די דירעקט מעטהאָדס געשטיצט דורך Arrays אין Java

מעטאָדבאַשרייַבונג
פּאָסל קלאָון ()קלאָונז די יגזיסטינג מענגע וואַלועס ווו באַווייַזן זענען נישט קאַפּיד
באָאָלעאַן יקוואַלז (כייפעץ 0)טשעקס צי עטלעכע אנדערע כייפעץ איז גלייַך צו די קראַנט כייפעץ
קלאַס ()קערט דער סאָרט נאָמען
שטריקל צו שטריקל ()רעטורנס אַ שטריקל פאַרטרעטונג פון די כייפעץ
ינט לענג ()קערט לענג פון די מענגע

Java Array Exception  

ערייז אין Java ווארפט ער די ונטער ויסנעם:

  • ArrayIndexOutOfBoundsException: דעם אַקערז ווען די אינדעקס ווערט מיר ספּעציפיצירן איז גרעסער ווי די לענג פון אַ מענגע אָדער ווען עס איז נעגאַטיוו. דאָס אַקערז דער הויפּט בשעת אַסיינינג ווערט אָדער אַקסעס מענגע עלעמענטן.

קאָפּי אַ מענגע  

מיר קענען צייכענען עלעמענטן פֿון איין מענגע צו אנדערן מיט די מעטהאָדס פון די סיסטעם סיסטעם.

זע אויך
לענג פון לאָנגעסט Fibonacci סובסעקווענסע

קאָפּי מענגע סינטאַקס

עפנטלעך פּאָסל אַרירעקאָפּי (Object src, int srcPos, Object dest, int destPos, int length);

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

פאָרן מענגע צו אַ אופֿן  

אין 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.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;
  }
}

סאָף  

דעם טוטאָריאַל גיט אַ דיטיילד באַשרייַבונג פון Arrays קלאַס אין Java, טייפּס פון ערייז אין Java, דערקלערן, שאַפֿן און ינישאַלייז ערייז מיט פאַרשידן אילוסטראציעס.

דערמאָנען