როგორ ინიცირება მასივი java



Array Java

როგორ ინიცირება მასივი java

მასივები java– ში ყველაზე ფართოდ გამოიყენება მონაცემთა სტრუქტურა, რომელიც ინახავს მონაცემთა ერთი და იგივე ტიპის მრავალ მნიშვნელობას თანმიმდევრული თანმიმდევრობით. მასივს აქვს ფიქსირებული სიგრძე და ინდექსი იწყება 0 – დან n – 1 – მდე, სადაც n არის მასივის სიგრძე. ჩვენ შეგვიძლია გამოვიყენოთ მასივების კლასი Java- ში, ნებისმიერი ტიპის მნიშვნელობის შესანახად, როგორიცაა სიმებიანი, მთელი რიცხვი, სიმბოლო, ბაიტი და მომხმარებლის მიერ განსაზღვრული ობიექტებიც კი. ჩვენ ვისწავლით როგორ დავიწყოთ მასივის ინიცირება ჯავაში?

ქვემოთ მოცემულია მთელი ელემენტების ერთგანზომილებიანი მასივის სქემატური გამოსახულება, რომელსაც აქვს 11 ელემენტი.

მასივები ჯავაში

სარჩევი

ჯავის მასივების მახასიათებლები

  • მასივს აქვს ფიქსირებული ზომა და მისი შეცვლა შეუძლებელია
  • მას შემდეგ, რაც მასივი დაფუძნებულია ინდექსზე, ადვილია შემთხვევითი ელემენტების წვდომა
  • გამოყოფს უწყვეტ მეხსიერებას მასივის ელემენტებისათვის.
  • ორივეს შენახვა შეუძლია პრიმიტიული და არაპრიმიტიული მონაცემები ღირებულებები

როგორ გამოვაცხადოთ მასივი Java- ში?

ჯავის მასივების დეკლარაცია

მასივის დეკლარირება შესაძლებელია ქვემოთ მოცემული გზებით. მასივის დეკლარაცია შეიცავს 2 ნაწილს, პირველი არის ელემენტების მონაცემთა ტიპი, რომელიც ჩვენ უნდა შევინახოთ მასივში (მაგალითად, int, String და ა.შ.), რასაც მოყვება მასივის სახელი. ფრჩხილებში აღნიშნულია, რომ ეს არის მასივი. როდესაც მასივს გამოვაცხადებთ, ის უბრალოდ ეუბნება შემდგენელს, რომ ცვლადი არის მასივი და რეალურად არ ქმნის მასივს.

მონაცემთა ტიპი [] arrayName; (ან)

მონაცემთა ტიპი [] 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];

როგორ დავიწყოთ მასივის ინიცირება ჯავაში?

როგორ მივიღოთ მასივი

მასივის ინიციალიზაცია ან მყისიერება ნიშნავს მასივის მნიშვნელობების მინიჭებას მასივის ზომის მიხედვით. ჩვენ ასევე შეგვიძლია შევქმნათ და დავიწყოთ მასივი (მყისიერად) ერთად (იხილეთ მეთოდი 1 ქვემოთ). ამ შემთხვევაში, ელემენტების რაოდენობა აღნიშნავს მასივის სიგრძეს ან ზომას. მეთოდი 2-ში ჩვენ მივცემთ მნიშვნელობებს ცალკე t0 თითოეულ ელემენტს. მას შემდეგ, რაც მასივის ინდექსი იწყება 0 – ით და მასივის ზომა აქ არის 3, მე –3 ელემენტს იკავებს მე –2 პოზიციას, რომელიც არის n – 1, სადაც 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- ში

Java- ში არსებობს 2 ტიპის მასივი:

  • ერთგანზომილებიანი მასივი - ეს შეიცავს მხოლოდ 1 მწკრივს და 1 სვეტს. ყველა ზემოთ ჩამოთვლილი მაგალითი ეკუთვნის ერთ განზომილებიან მასივს
  • მრავალგანზომილებიანი მასივი - ეს შეიცავს მრავალ რიგს და მრავალ სვეტს. სხვა სიტყვებით რომ ვთქვათ, ეს არის მასივების მასივი, სადაც ყველა რიგს აქვს იგივე რაოდენობის სვეტი. მაგ: 2 * 2 მატრიცა
  • Jagged მასივი - თითოეული მწკრივი შეიცავს სვეტების სხვადასხვა რაოდენობას

მრავალგანზომილებიანი მასივები java

მრავალგანზომილებიან მასივებს შეიძლება ჰქონდეს მრავალი მწკრივი და სვეტი. პირველი ინდექსი [] წარმოადგენს სტრიქონებს, ხოლო მეორე [] წარმოადგენს სვეტებს.

მაგ: 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

მთელი რიცხვების 2D მასივის მაგალითი

აქ, ჩვენ ვქმნით 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 

Jagged მასივები ჯავაში

Jagged მასივი ასევე არის ორგანზომილებიანი მასივი, რომელსაც აქვს სხვადასხვა რაოდენობის სვეტები. სხვა სიტყვებით რომ ვთქვათ, თითოეულ სტრიქონს აქვს სხვადასხვა რაოდენობის სვეტი. Jagged მასივის ინიცირება განსხვავდება ჩვეულებრივი 2D მასივისგან.

Jagged მასივის ინიციალიზაცია

მასივის შექმნის დროს ჩვენ ვადგენთ მწკრივების რაოდენობას. ამ მაგალითში, ეს არის 2. მომდევნო 2 განცხადებაში, თითოეული მწკრივის მასივისთვის, ჩვენ მიუთითეთ სვეტების რაოდენობა. აქ, 1 რიგს აქვს 3 სვეტი და მე -2 რიგს აქვს 4 სვეტი.

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

Jagged მასივის მაგალითი მარყუჟის მნიშვნელობების მინიჭებით

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 

Jagged მასივის მაგალითი მასივის შექმნის დროს მნიშვნელობების ინიციალიზებით

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- ში

მეთოდიაღწერა
ბათილი კლონი ()ახასიათებს მასივის არსებულ მნიშვნელობებს, სადაც ცნობები არ არის კოპირებული
ლოგიკური ტოლია (ობიექტი 0)ამოწმებს, უდრის თუ არა სხვა ობიექტი მიმდინარე ობიექტს
კლასი getClass ()აბრუნებს კლასის სახელს
სიმებიანი toString ()აბრუნებს ობიექტის სიმების წარმოდგენას
int სიგრძე ()აბრუნებს მასივის სიგრძეს

ჯავის მასივის გამონაკლისები

მასივები ჯავა ისვრის ქვემოთ გამონაკლისი:

  • ArrayIndexOutOfBoundsException: ეს ხდება მაშინ, როდესაც ჩვენ მიერ მითითებული ინდექსის მნიშვნელობა აღემატება მასივის სიგრძეს ან უარყოფითია. ეს ხდება ძირითადად მნიშვნელობის მინიჭების ან მასივის ელემენტებზე წვდომის დროს.

მასივის კოპირება

ელემენტების კოპირება შეგვიძლია ერთი მასივიდან მეორეში სისტემის სისტემის arraycopy მეთოდის გამოყენებით.

მასივის სინტაქსის კოპირება

ბათილი საზოგადოებრივი არიკოპია (Object src, int srcPos, Object dest, int destPos, int სიგრძე);

src-source მასივის ობიექტი, რომლის კოპირებაც ხდება

srcPos - საწყისი პოზიცია მასივში

dest - დანიშნულების მასივის ობიექტი, რომლის კოპირებაც ხდება

destPos - საწყისი პოზიცია დანიშნულების მასივში

სიგრძე - მასივის ელემენტების კოპირება

მასივის კოპირების მაგალითი

ქვემოთ მოცემულ მაგალითში, ჩვენ ვაკოპირებთ 4 ელემენტს საწყისი წყაროს მასივიდან დანიშნულების მასივში. აქედან გამოდის ბეჭდვა "java" "

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 პაკეტს. Java.util.Array კლასის მხარდაჭერილი რამდენიმე ოპერაცია არსებობს, როგორც ქვემოთ არის ნახსენები:

  • 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;
  }
}

დასკვნა

ამ სახელმძღვანელოში მოცემულია მასივების კლასის ჯავას დეტალური აღწერა, მასივების ტიპები ჯავაში, მასივების დეკლარირება, შექმნა და ინიცირება სხვადასხვა ილუსტრაციებით.

Reference