1. Stringtatasusunan

Saya ingin memberi anda gambaran ringkas tentang Stringtatasusunan.

Seperti yang kami katakan sebelum ini, tatasusunan boleh terdiri daripada sebarang jenis. Ini bermakna anda boleh membuat tatasusunan Strings. Jika kami ingin menulis atur cara yang "membaca 10 baris daripada papan kekunci dan memaparkannya dalam susunan terbalik", berikut ialah rupa kod tersebut:

Scanner console = new Scanner(System.in);
String[] array = new String[10];
for (int i = 0; i < 10; i++)
{
   array[i] = console.nextLine();
}
for (int i = 9; i >= 0; i--)
{
   System.out.println(array[i]);
}
Cipta Scannerobjek
Cipta objek tatasusunan 10 elemen
Gelung dari 0 hingga 9

Baca rentetan daripada papan kekunci dan simpan dalam sel tatasusunan seterusnya
Gelung dari 9 hingga 0

Paparkan sel seterusnya dalam tatasusunan

Kod hampir tidak berubah! Kami hanya perlu menggantikan intdengan Stringapabila mencipta tatasusunan. Nah, dan apabila membaca rentetan dari papan kekunci, kami juga menggantikan nextInt()kaedah dengan nextLine().


2. Stringtatasusunan dalam ingatan

Dan satu lagi fakta berguna. Mari kita pertimbangkan 3 gambar:

Gambar 1. Bagaimana Stringobjek disusun dalam ingatan:

Tatasusunan rentetan dalam ingatan

Gambar ini diambil dari pelajaran lepas.

Sila ambil perhatian bahawa teks rentetan tidak disimpan secara langsung dalam pembolehubah: blok memori yang berasingan diperuntukkan untuknya. Pembolehubah Stringmenyimpan alamat (rujukan) kepada objek yang menyimpan teks.

Gambar 2. Bagaimana tatasusunan integer disusun dalam ingatan:

Tatasusunan rentetan dalam ingatan 2

Gambar ni pun biasa.

Gambar 3. Bagaimana tatasusunan rentetan disusun dalam ingatan:

Bagaimana tatasusunan String disusun dalam ingatan

Di sebelah kiri kita melihat pembolehubah tatasusunan yang jenisnya String[](ia menyimpan alamat objek tatasusunan).

Di tengah, kita mempunyai Stringobjek tatasusunan itu sendiri.

Dan di sebelah kanan adalah objek rentetan yang menyimpan beberapa teks.

Sel tatasusunan Stringtidak menyimpan rentetan itu sendiri (teks objek Rentetan). Sebaliknya, mereka menyimpan alamat mereka (rujukan kepada mereka). Dengan cara yang sama bahawa Stringpembolehubah menyimpan alamat objek rentetan (di mana teks disimpan).

Pertimbangkan perkara ini apabila anda membandingkan sel tatasusunan:

String[] array = new String[10];

array[1] = "Hello";
array[2] = array[1];
array[3] = new String("Hello");
// Compare
array[1] == array[2];
array[1] == array[3];
array[1].equals(array[3]);
array[1].equalsIgnoreCase(array[3]);
Buat tatasusunan 10 rentetan

Letakkan nilai ke dalam tatasusunan



false (rujukan adalah sama)
false (rujukan tidak sama)
true (rentetan adalah sama)
true(rentetan masih sama)


3. Inisialisasi tatasusunan pantas dalam Java

Tatasusunan sangat berguna, jadi pencipta Java cuba membuat kerja dengannya semudah mungkin.

Perkara pertama yang mereka lakukan adalah untuk memudahkan pemulaan tatasusunan, proses yang anda gunakan untuk membekalkan nilai awal tatasusunan.

Lagipun, sebagai tambahan kepada data yang dibaca dari suatu tempat, program juga sering memerlukan data dalamannya sendiri untuk berfungsi. Sebagai contoh, katakan kita perlu menyimpan panjang setiap bulan dalam tatasusunan. Inilah rupa kod tersebut:

int[] months = new int[12];
months[0] = 31; // January
months[1] = 28; // February
months[2] = 31; // March
months[3] = 30; // April
months[4] = 31; // May
months[5] = 30; // June
months[6] = 31; // July
months[7] = 31; // August
months[8] = 30; // September
months[9] = 31; // October
months[10] = 30; // November
months[11] = 31; // December

Tetapi terima kasih kepada pencipta Java, terdapat cara untuk menulis ini dengan lebih ringkas:

// Lengths of months of the year
int[] months = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

Anda hanya boleh menyenaraikan semua nilai tatasusunan, dipisahkan dengan koma!

Mudah, bukan? Tetapi bukan itu sahaja.

Seperti yang berlaku, pengkompil boleh menentukan jenis bekas (objek tatasusunan) berdasarkan jenis nilai tatasusunan. Dan untuk menentukan panjang tatasusunan, adalah remeh untuk mengira bilangan elemen yang ditulis dalam pendakap kerinting.

Ini bermakna kod ini boleh ditulis lebih pendek:

// Lengths of months of the year
int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

Satu perkara yang indah, bukan? ๐Ÿ™‚

Ini dipanggil "pemulaan tatasusunan pantas". Dengan cara ini, ini berfungsi untuk jenis selain daripada int...

// Names of months of the year
String[] months = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November ", "December"};