Program Java mengakses semua data sebagai tatasusunan objek

Tatasusunan ialah struktur data linear yang digunakan untuk menyimpan kumpulan elemen dengan jenis data yang serupa. Kami boleh mencipta tatasusunan menggunakan jenis data primitif dan memandangkan kelas dianggap sebagai jenis data yang ditentukan pengguna, kami boleh mencipta tatasusunan objek juga.

Dalam artikel ini, kita akan membincangkan tatasusunan objek dan mencipta atur cara java untuk mengakses semua data dalam bentuk tatasusunan objek.

Susunan Objek atau Susunan Objek

Tatasusunan objek sebenarnya mengandungi pembolehubah rujukan objek, iaitu elemen yang disimpan dalam tatasusunan objek adalah jenis rujukan. Kami mengikuti sintaks yang sama untuk mencipta tatasusunan primitif dan tatasusunan objek. Walau bagaimanapun, dalam kes tatasusunan objek, kami menggunakan nama kelas dan bukannya jenis data primitif.

Sintaks tatasusunan primitif

Data_Type[] nameOfarray; 
// declaration
Or,
Data_Type nameOfarray[]; 
// declaration
Or,
// declaration with size
Data_Type nameOfarray[] = new Data_Type[sizeofarray]; 
// declaration and initialization
Data_Type nameOfarray[] = {values separated with comma};

Contoh

String[] item = new String[5]; 

Dalam contoh di atas, kami mencipta tatasusunan rentetan yang boleh menyimpan 5 elemen rentetan.

Sintaks tatasusunan objek

Class_name objectArray[]; 
// declaration
Or,
// declaration and instantiation
Class_name objectArray[] = new Class_name[sizeofarray];

Contoh

Cart[ ] obj = new Cart[5];

Dalam contoh di atas, kami mencipta tatasusunan objek yang boleh menyimpan 5 objek kelas Cart. Kami menggunakan nama kelas dan bukannya jenis data primitif.

Sila ingat bahawa apabila kami mengisytiharkan dan memulakan tatasusunan objek, ia tidak mencipta objek secara automatik untuk elemen, sebaliknya kami perlu mencipta objek untuk setiap elemen secara individu.

Selepas membuat instantiate tatasusunan objek, kita perlu memulakan elemen tatasusunan dengan nilai. Dalam kes ini, objek adalah elemen. Satu cara untuk menghantar nilai adalah dengan menggunakan pembina kelas, atau kita boleh mencipta berbilang objek dan kemudian menghantarnya ke tatasusunan objek yang lain.

Tatabahasa

arrayObject_name[index] = new constructor_name( values );
Or,
arrayObject_name[index] = object_name;

Kita akan lihat contoh dalam bahagian seterusnya.

Atur cara Java mengakses semua data dalam bentuk tatasusunan objek

Contoh 1

Dalam contoh berikut, kami akan mencipta tatasusunan objek dan memulakannya dengan nilai menggunakan pembina.

class Cart {
   String item;
   double price;
   Cart(String item, int price) { 
      // Constructor
      this.item = item;
      this.price = price;
   }
}
public class Main {
   public static void main(String[] args) {
      Cart[ ] obj = new Cart[5]; 
      // creation of object array
      // Passing values to the array object
      obj[0] = new Cart("Rice", 59); 
      obj[1] = new Cart("Milk", 60);
      obj[2] = new Cart("Bread", 45);
      obj[3] = new Cart("Peanut", 230);
      obj[4] = new Cart("Butter", 55);
      System.out.println("Accessing data as Object Array: ");
      int i = 0; 
      // initialization of loop variable
      while(i < obj.length) {  
         // to iterate through array obejct
         System.out.println("Item: " +obj[i].item + ", " + "Price: " +obj[i].price);
         // to print the values
         i++; 
         // incrementing loop variable
      }
   }
}

Output

Accessing data as Object Array: 
Item: Rice, Price: 59.0
Item: Milk, Price: 60.0
Item: Bread, Price: 45.0
Item: Peanut, Price: 230.0
Item: Butter, Price: 55.0

Dalam contoh di atas, kami telah mencipta kelas "Cart" dan pembinanya "Cart" yang menerima dua parameter "item" dan "price". Dalam kaedah utama kami mencipta pelbagai objek "obj" bersaiz 5 kelas "Cart". Dengan menggunakan pembina "Cart", elemen tatasusunan dimulakan. Kami menggunakan gelung while untuk mencetak nilai.

Contoh 2

Contoh berikut menggambarkan cara lain untuk mengakses data sebagai tatasusunan objek.

class Cart {
   String item;
   double price;
}
public class Arrayobj {
   public static void main(String []args) {
      // Initializing the values to the variables
      Cart c1 = new Cart(); 
      // object 1
      c1.item = "Rice";
      c1.price = 59;
      Cart c2 = new Cart(); 
      // object 2
      c2.item = "Milk";
      c2.price = 60;
      Cart c3 = new Cart(); 
      // object 3
      c3.item = "Bread";
      c3.price = 45;
      Cart obj[] = new Cart[3]; 
      // array of object
      // Passing objects to object array
      obj[0] = c1; 
      obj[1] = c2;
      obj[2] = c3;
      for(int i = 0; i < obj.length ; i++ ) {
         System.out.println("Item: " +obj[i].item + ", " + "Price: " +obj[i].price);
      }
   }
}

Output

Item: Rice, Price: 59.0
Item: Milk, Price: 60.0
Item: Bread, Price: 45.0

Dalam contoh di atas, kami mencipta kelas "Cart" dan tiga objeknya "c1", "c2", "c3". Selain itu, kami telah mencipta pelbagai objek "obj" bersaiz 3 kelas "Cart". Dengan menggunakan objek, elemen tatasusunan dimulakan. Kami menggunakan gelung untuk mencetak nilai.

Kesimpulan

Dalam artikel ini, kami mempelajari tentang persamaan dan perbezaan antara tatasusunan primitif dan tatasusunan objek. Dengan bantuan dua program java, kami membincangkan cara mengakses data dalam bentuk tatasusunan objek.

Atas ialah kandungan terperinci Program Java mengakses semua data sebagai tatasusunan objek. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!