Sesuatu tentang tatasusunan

Hai! Sebelum ini dalam latihan anda, kami telah bekerja dengan objek tunggal (dan jenis primitif). Tetapi bagaimana jika kita perlu bekerja dengan seluruh kumpulan objek dan bukannya hanya satu? Sebagai contoh, katakan kami ingin membuat senarai hari lahir semua pekerja di syarikat kami. Ia harus mengandungi 30 rentetan yang diformatkan seperti berikut: "Sarah Huffman, 25 Januari" Kami akan mendapat manfaat daripada struktur data khas yang dipanggil tatasusunan . Jika kita membandingkan tatasusunan dengan objek sebenar, ia sangat serupa dengan peti besi bank dengan peti deposit keselamatan: Tatasusunan juga terdiri daripada "kotak". Anda boleh meletakkan sesuatu (elemen) ke dalam setiap kotak. Untuk mengakses elemen, anda perlu mengetahui nombor kotaknya (indeks). Beginilah cara tatasusunan dibuat:

public class Main {

   public static void main(String[] args) {

       String [] birthdays = new String[10];
      
   }
}

Di sini kita mencipta tatasusunan yang mengandungi 10 elemen. Anda boleh segera perhatikan beberapa ciri tatasusunan:

1. Ia menyimpan elemen jenis data yang jelas . Jika kita mencipta tatasusunan String, kita tidak boleh menyimpan apa-apa lagi di dalamnya. Jenis data ditentukan apabila tatasusunan dibuat . Di sinilah ia berbeza daripada peti deposit keselamatan (di mana pelanggan boleh menyimpan apa yang dia mahukan).


2. Saiznya mesti dinyatakan apabila tatasusunan dibuat . Anda tidak boleh menunjukkannya kemudian atau menukar saiznya selepas tatasusunan dibuat .

Fakta bahawa kita mencipta tatasusunan ditunjukkan oleh kurungan segi empat sama pada kedua-dua belah ungkapan. Ia boleh ditentukan sebelum atau selepas nama pembolehubah rujukan. Sama ada cara akan berfungsi:

String [] birthdays = new String[10];
String birthdays [] = new String[10];

Jika anda ingin menulis sesuatu ke dalam tatasusunan, anda perlu menentukan indeks kotak di mana nilai akan ditulis. Kotak dalam tatasusunan diberi nombor bermula dari 0. Mengira bermula dari sifar adalah amalan yang sangat biasa dalam pengaturcaraan. Lebih cepat anda membiasakannya, lebih baik :) Ini bermakna, jika anda ingin meletakkan beberapa nilai dalam kotak pertama , anda lakukan ini:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
   }
}

Sekarang hari lahir Jana disimpan dalam sel pertama susunan hari lahir pekerja kami: Anda boleh menambah nilai lain dengan cara yang sama:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";
   }
}

Ambil perhatian bahawa kami menambah hari lahir Rosie pada kotak kelapan (anda tidak lupa mengapa Kotak No. 7 adalah kotak kelapan, bukan?) . Anda boleh lihat bahawa kami belum mengisi semua sel lain. Kita tidak perlu menulis nilai ke dalam tatasusunan mengikut urutan. Tiada keperluan sedemikian. Sudah tentu, menulis elemen mengikut urutan menjadikannya lebih mudah untuk menjejaki berapa banyak kotak yang kosong dan berapa banyak yang diduduki, dan ia menghalang tatasusunan daripada mempunyai "lubang". Jika anda ingin mendapatkan kandungan salah satu kotak, maka (sama seperti peti deposit keselamatan) anda perlu mengetahui nombornya. Ini adalah cara ia dilakukan:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

       String rosieBirthday = birthdays[7];
       System.out.println(rosieBirthday);
   }
}

Output konsol: Rosie Mills, 3 Januari Kami mencipta Stringpembolehubah dan memberitahu pengkompil: "Cari kotak dengan indeks 7 dalam tatasusunan hari lahir , dan tetapkan nilai yang terkandung di sana kepada pembolehubah StringrosieBirthday " . Dan itulah yang dilakukannya. Apabila bekerja dengan tatasusunan, kita boleh mencari panjangnya dengan mudah menggunakan sifat khas: length .

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

       int birthdaysLength = birthdays.length;
       System.out.println(birthdaysLength);
   }
}

Output konsol: 10 Nota: lengthHarta ini menyimpan saiz tatasusunan, bukan bilangan kotak yang penuh. Tatasusunan kami hanya menyimpan 3 nilai, tetapi kami menunjukkan saiznya sebagai 10 apabila kami menciptanya. Dan ini betul-betul nilai yang lengthdipulangkan oleh medan itu. Mengapa ini berguna? Baiklah, katakan anda ingin memaparkan senarai semua hari lahir (untuk mengesahkan bahawa tiada siapa yang dilupakan). Anda boleh melakukan ini dalam satu gelung mudah:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[2] = "Jeremiah Leonard, July 12";
       birthdays [3] = "Kenny Russo, September 7";
       birthdays[4] = "Tommie Barnes, November 9";
       birthdays [5] = "Roman Baranov, August 14";
       birthdays [6] = "Chanice Andersen, April 1";
       birthdays[7] = "Rosie Mills, January 3";
       birthdays [8] = "Keenan West, October 19";
       birthdays [9] = "Abraham McArthur, May 3";

       for (int i = 0; i < birthdays.length; i++) {
           System.out.println(birthdays[i]);
       }
   }
}

Dalam gelung, kami mengisytiharkan pembolehubah i, yang dimulakan kepada sifar. Pada setiap pas, kami mendapat elemen dengan indeks i daripada tatasusunan kami dan memaparkan nilainya. Gelung akan melakukan 10 lelaran, dan saya akan meningkat daripada 0 kepada 9—dan nombor menjadi indeks bagi elemen tatasusunan kami! Hasilnya, kami akan memaparkan semua nilai daripada hari lahir[0] hingga hari lahir[9] Sebenarnya, terdapat satu lagi cara anda boleh membuat tatasusunan. Sebagai contoh, anda boleh membuat tatasusunan ints seperti ini:

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
   }
}

Teknik ini dipanggil "pemulaan pintasan". Ia agak mudah, kerana kami mencipta tatasusunan dan mengisinya dengan nilai secara serentak. Kita tidak perlu menyatakan saiz tatasusunan secara eksplisit: dengan pengamulaan pintasan, medan lengthditetapkan secara automatik.

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
       System.out.println(numbers.length);
   }
}

Output konsol: 9 Sekarang, sedikit tentang cara tatasusunan disimpan dalam ingatan. Katakan kita mempunyai tatasusunan tiga Catobjek:

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");
   }
}

Anda perlu memahami beberapa perkara di sini:

1. Dalam kes primitif, tatasusunan menyimpan set nilai tertentu (cth ints). Dalam kes objek, tatasusunan menyimpan satu set rujukan .
   Tatasusunan catsterdiri daripada tiga elemen, setiap satunya adalah rujukan kepada Catobjek. Setiap rujukan menunjuk ke alamat memori tempat objek yang sepadan disimpan.

2. Elemen tatasusunan disusun dalam satu blok dalam ingatan. Ini dilakukan untuk membolehkan mereka diakses dengan cepat dan cekap.

Oleh itu, catsmerujuk blok memori di mana semua objek (elemen tatasusunan) disimpan. Cats[0]merujuk alamat tertentu dalam blok ini. Adalah penting untuk memahami bahawa tatasusunan bukan sahaja menyimpan objek: ia adalah objek itu sendiri. Ini membawa kita kepada persoalan sama ada kita boleh mencipta bukan sahaja tatasusunan rentetan atau nombor, tetapi juga tatasusunan tatasusunan . Dan jawapannya ya, kita boleh! Tatasusunan boleh menyimpan sebarang objek, termasuk tatasusunan lain. Tatasusunan sedemikian dipanggil dua dimensi . Jika kita mewakilinya secara visual, ia akan menjadi sangat serupa dengan jadual biasa. Katakan, kita ingin mencipta tatasusunan 3 tatasusunan yang setiap satu boleh menyimpan 10 intsaat. Ia akan kelihatan seperti ini: Setiap baris mewakili inttatasusunan. Tatasusunan pertama mengandungi nombor dari 1 hingga 10, tatasusunan kedua — dari -1 hingga -10, dan yang ketiga — satu set nombor rawak. Setiap tatasusunan ini disimpan dalam kotak tatasusunan dua dimensi kami. Dalam kod, permulaan tatasusunan dua dimensi kelihatan seperti ini:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
}

Kucing tatasusunan dua dimensi kami menyimpan 3 tatasusunan dengan 5 kotak dalam setiap tatasusunan. Jika kita ingin meletakkan objek dalam kotak ketiga tatasusunan kedua, kita akan melakukan ini:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
   cats[1][2] = new Cat("Fluffy");
}

[1]menunjukkan tatasusunan kedua, dan [2]menunjukkan kotak ketiga tatasusunan itu. Oleh kerana tatasusunan dua dimensi terdiri daripada beberapa tatasusunan, untuk melelar melaluinya dan memaparkan semua nilainya (atau mengisi semua elemennya), kami memerlukan gelung bersarang:

for (int i = 0; i < cats.length; i++) {
   for (int j = 0; j < cats[i].length; j++) {
       System.out.println(cats[i][j]);
   }
}

Dalam gelung luar (pembolehubah i), kami mengulangi semua tatasusunan dalam tatasusunan dua dimensi kami. Dalam gelung dalaman (pembolehubah j), kita melalui semua elemen setiap tatasusunan. Akibatnya, kucing[0][0] (tatasusunan pertama, elemen pertama) akan dipaparkan dahulu, diikuti oleh kucing[0][1] (tatasusunan pertama, elemen kedua). Selepas kami melalui tatasusunan pertama, kami akan memaparkan cats[1][0] , cats[1][1] , cats[1][2] , dsb. Dengan cara ini, tatasusunan dua dimensi juga menyokong permulaan singkatan:

int[][] numbers = {{1,2,3}, {4,5,6}, {7,8,9}};

Biasanya, kami akan mengisytiharkan tatasusunan dua dimensi numberssebagai int[3][3], tetapi singkatan ini membolehkan kami menentukan nilai dengan segera. Mengapa anda memerlukan tatasusunan dua dimensi? Nah, anda boleh menggunakannya untuk mencipta semula permainan "Battleship" yang terkenal dengan mudah: Dalam "Battleship", struktur padang permainan boleh diterangkan dengan mudah: susunan dua dimensi 10 tatasusunan dengan 10 elemen setiap satu. Anda membuat dua tatasusunan ini (satu untuk anda dan satu untuk lawan anda)

int[][] battleshipBoard1 = new int[10][10];
int[][] battleshipBoard2 = new int[10][10];

gunakan beberapa nilai (cth nombor atau simbol) untuk mengisi elemen yang sepadan dengan lokasi kapal anda, dan kemudian bergilir-gilir memanggil koordinat untuk elemen tertentu:

• BattleshipBoard1[0][2]!
• Cik! kapal perangBoard2[2][4]!
• Pukul!
• BattleshipBoard2[2][5]!
• Pukul!
• BattleshipBoard2[2][6]!,
• Tenggelam!

Ini menyimpulkan pengenalan pertama tatasusunan kami, tetapi ia hanya permulaan interaksi kami dengan mereka. Dalam pelajaran berikut, kita akan melihat cara menarik ia boleh digunakan, dan juga mempelajari fungsi terbina dalam Java untuk membolehkan kita bekerja dengan struktur data ini dengan lebih mudah :)