Tatasusunan di Jawa

Bayangkan kabinet di dalam bilik simpanan. Setiap daripada mereka mempunyai nombor sendiri, dan setiap daripada mereka menyimpan beberapa objek Bagasi. Atau senarai wain di mana setiap jenis wain dinomborkan dan anda memesan dengan memberikan nombor minuman anda. Atau senarai pelajar di mana "Adams" direkodkan di kedudukan pertama dan "Zimmer" adalah yang terakhir. Atau senarai penumpang di dalam kapal terbang, yang masing-masing diberikan tempat duduk bernombor. Di Jawa, tatasusunan sering digunakan untuk bekerja dengan struktur sedemikian, iaitu set data homogen.

Apakah tatasusunan?

Tatasusunan ialah struktur data yang menyimpan elemen dari jenis yang sama. Anda boleh menganggapnya sebagai satu set sel bernombor. Anda boleh meletakkan beberapa data dalam setiap sel (satu elemen data setiap sel). Sel tertentu diakses menggunakan nombornya. Nombor elemen dalam tatasusunan juga dipanggil indeks . Di Jawa, tatasusunan adalah homogen, iaitu semua selnya mengandungi unsur-unsur jenis yang sama. Oleh itu, tatasusunan integer hanya mengandungi integer ( int ), tatasusunan rentetan — rentetan sahaja dan tatasusunan tika kelas Anjing yang telah kami buat akan mengandungi hanya objek Anjing . Dalam erti kata lain, Java tidak akan membenarkan kami meletakkan integer dalam sel pertama tatasusunan, String di kedua, dan Anjing di ketiga.

Mengisytiharkan tatasusunan

Bagaimanakah anda mengisytiharkan tatasusunan?

Seperti mana-mana pembolehubah, tatasusunan mesti diisytiharkan dalam Java. Ini boleh dilakukan dalam satu daripada dua cara. Mereka adalah setara, tetapi cara pertama adalah lebih konsisten dengan gaya Java. Yang kedua ialah warisan bahasa C: banyak pengaturcara C beralih ke Java, dan kaedah alternatif disimpan untuk kemudahan mereka. Jadual menunjukkan kedua-dua cara mengisytiharkan tatasusunan dalam Java: Dalam kedua-dua kes, dataType ialah jenis pembolehubah dalam tatasusunan. Dalam contoh, kami mengisytiharkan dua tatasusunan. Satu akan menyimpan int s, dan satu lagi - Objek objek . Oleh itu, pengisytiharan tatasusunan mempunyai nama dan jenis (jenis elemen tatasusunan). ArrayName ialah nama array.

Mencipta tatasusunan

Bagaimanakah anda membuat tatasusunan?

Seperti mana-mana objek lain, anda boleh mencipta tatasusunan Java, iaitu menempah tempat dalam ingatan untuknya, menggunakan operator baharu . Ini adalah cara ia dilakukan:

new typeOfArray[length]; 

dengan typeOfArray ialah jenis tatasusunan dan panjang ialah panjangnya (iaitu bilangan sel) yang dinyatakan sebagai nombor bulat ( int). Tetapi ambil perhatian bahawa di sini kami hanya memperuntukkan memori untuk tatasusunan - kami tidak mengaitkan tatasusunan yang diisytiharkan dengan mana-mana pembolehubah yang diisytiharkan sebelum ini. Biasanya, tatasusunan mula-mula diisytiharkan dan kemudian dijadikan instantiated, sebagai contoh:

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

Di sini kami mencipta tatasusunan integer yang dipanggil myArray , memaklumkan pengkompil bahawa ia terdiri daripada 10 sel (setiap satunya akan mengandungi integer). Walau bagaimanapun, adalah lebih biasa untuk menggunakan sintaks singkatan berikut untuk mencipta tatasusunan serta-merta apabila ia diisytiharkan:

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

Sila ambil perhatian:Selepas tatasusunan dibuat menggunakan operator baharu , selnya mengandungi nilai lalai. Untuk jenis angka (seperti dalam contoh kami), nilai lalai ialah 0, untuk jenis boolean , ia adalah false , dan untuk jenis rujukan, ia adalah null . Justeru, selepas melaksanakan kenyataan ini

int[] myArray = new int[10];

kita mendapat tatasusunan sepuluh integer dan, sehingga program melakukan sesuatu untuk menukar nilai, setiap sel mengandungi 0.

Panjang tatasusunan di Jawa

Seperti yang kita katakan di atas, panjang tatasusunan ialah bilangan elemen yang direka bentuk untuk disimpan oleh tatasusunan. Panjang tatasusunan tidak boleh diubah selepas ia dibuat. Sila ambil perhatianbahawa elemen tatasusunan dinomborkan bermula dari sifar di Jawa. Oleh itu, jika kita mempunyai tatasusunan 10 elemen, maka indeks unsur pertama ialah 0 dan indeks yang terakhir ialah 9. Anda boleh mendapatkan panjang tatasusunan menggunakan pembolehubah panjang . Sebagai contoh:

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

Pengeluaran:

10

Memulakan tatasusunan dan mengakses elemennya

Sekarang kita tahu cara membuat tatasusunan dalam Java. Proses ini memberi kita bukan tatasusunan kosong, tetapi tatasusunan yang diisi dengan nilai lalai. Sebagai contoh, untuk tatasusunan int , ini ialah 0, dan jika kita mempunyai tatasusunan sebarang jenis rujukan, maka lalai dalam setiap sel ialah null . Kami mengakses elemen tatasusunan (contohnya, untuk menetapkan nilainya, memaparkannya pada skrin atau melakukan beberapa operasi dengannya) dengan indeksnya. Inisialisasi tatasusunan ialah proses mengisi tatasusunan dengan nilai tertentu (selain lalai). Contoh: mari buat tatasusunan rentetan untuk 4 musim dan isikannya dengan nama musim.

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

Sekarang nama musim ditulis pada empat sel tatasusunan kami. Kita boleh memulakan tatasusunan dengan cara yang berbeza, menggabungkan pengisytiharan dan permulaan:

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

Apatah lagi, pengendali baharu boleh diabaikan:

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

Bagaimanakah anda memaparkan tatasusunan pada skrin di Jawa?

Anda boleh memaparkan elemen tatasusunan pada skrin (iaitu pada konsol) menggunakan gelung for . Satu lagi cara yang lebih pendek untuk memaparkan tatasusunan akan dibincangkan dalam perenggan bertajuk " Kaedah berguna untuk bekerja dengan tatasusunan ". Sementara itu, lihat contoh ini di mana tatasusunan dipaparkan menggunakan gelung:

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"}; 
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]); 
}

Program ini akan memaparkan perkara berikut:

Winter 
Spring 
Summer 
Autumn

Tatasusunan satu dimensi dan pelbagai dimensi di Jawa

Tetapi bagaimana jika kita tidak mahu mencipta tatasusunan nombor, rentetan atau objek lain, sebaliknya tatasusunan? Java membolehkan anda melakukan ini. Jenis tatasusunan yang sudah kita kenali ( int[] myArray = new int[8] ) dikenali sebagai tatasusunan satu dimensi. Tetapi tatasusunan tatasusunan dipanggil tatasusunan dua dimensi. Ia seperti jadual yang mempunyai nombor baris dan nombor lajur. Atau, jika anda telah mempelajari asas algebra linear, anda boleh menganggapnya sebagai matriks. Mengapa kita memerlukan tatasusunan sedemikian? Nah, untuk memprogramkan matriks dan jadual, serta objek lain yang mempunyai struktur yang serupa. Sebagai contoh, papan catur boleh diwakili oleh tatasusunan 8x8. Tatasusunan berbilang dimensi diisytiharkan dan dibuat seperti berikut:

Int[][] myTwoDimentionalArray = new int[8][8];

Tatasusunan ini mempunyai tepat 64 elemen: myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray[1][0] , myTwoDimentionalArray[1][1] dan seterusnya sehingga myTwoDimentionalArray[7][7] . Jadi jika kita menggunakannya untuk mewakili papan catur, maka A1 sepadan dengan myTwoDimentionalArray[0][0] dan E2 sepadan dengan myTwoDimentionalArray[4][1] . Tetapi sejauh mana kita boleh menolak ini? Di Jawa, anda boleh menentukan tatasusunan tatasusunan... tatasusunan tatasusunan, dan sebagainya. Sudah tentu, tatasusunan tiga dimensi dan dimensi lebih tinggi digunakan sangat jarang. Yang berkata, anda boleh menggunakan tatasusunan tiga dimensi untuk memprogramkan kiub Rubik, sebagai contoh.

Kaedah berguna untuk bekerja dengan tatasusunan

Java mempunyai kelas java.util.Arrays untuk bekerja dengan tatasusunan. Secara umum, operasi yang paling biasa dilakukan pada tatasusunan ialah pemulaan (mengisi dengan elemen), mendapatkan semula elemen (mengikut indeks), menyusun dan mencari. Mencari dan menyusun tatasusunan adalah topik untuk hari lain. Di satu pihak, adalah amalan yang baik untuk menulis sendiri beberapa algoritma carian dan pengisihan. Sebaliknya, semua algoritma terbaik telah pun dilaksanakan dan dimasukkan ke dalam perpustakaan Java standard, dan anda boleh menggunakannya secara sah. Berikut ialah tiga kaedah berguna dalam kelas ini.

Mengisih tatasusunan

Kaedah void sort(int[] myArray, int fromIndex, int toIndex) mengisih tatasusunan integer atau subarray dalam tertib menaik.

Mencari elemen dalam tatasusunan

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key) . Kaedah ini mencari elemen utama dalam tatasusunan atau subarray myArray yang diisih , daripada fromIndex ke toIndex . Jika item itu dijumpai, maka ia mengembalikan indeksnya. Jika tidak, ia mengembalikan (-fromIndex)-1 .

Menukar tatasusunan kepada rentetan

Kaedah String toString(int[] myArray) menukar tatasusunan kepada rentetan. Dalam Java, tatasusunan tidak mengatasi toString() . Ini bermakna jika anda cuba memaparkan keseluruhan tatasusunan sekaligus (System.out.println(myArray)) dan bukannya satu elemen pada satu masa seperti dalam perenggan bertajuk " Paparkan tatasusunan pada skrin ", anda akan mendapat nama kelas dan cincang heksadesimal tatasusunan (ditakrifkan oleh Object.toString() ). Jika anda seorang pemula, anda mungkin tidak memahami penjelasan tentang kaedah toString . Pada mulanya, anda tidak perlu, tetapi menggunakan kaedah ini menjadikannya lebih mudah untuk memaparkan tatasusunan. Java membolehkan anda memaparkan tatasusunan dengan mudah tanpa menggunakan gelung. Contoh di bawah menunjukkan ini.

Contoh menggunakan sort, binarySearch dan toString

Mari kita cipta tatasusunan integer, paparkannya menggunakan toString , susun menggunakan kaedah isihan , dan kemudian cari beberapa nombor di dalamnya.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

Pengeluaran:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

Rentetan pertama ialah percubaan untuk memaparkan tatasusunan tanpa menggunakan toString . Yang kedua ialah tatasusunan yang dipaparkan menggunakan toString . Yang ketiga ialah tatasusunan yang diisih. Keempat ialah indeks nombor yang kami cari (5) dalam tatasusunan yang diisih (ingat bahawa kami mengira dari sifar, jadi indeks elemen keempat tatasusunan ialah 3). Dalam rentetan kelima, kita lihat -1. Ini ialah indeks tatasusunan yang tidak sah. Ia menandakan bahawa nombor yang kami cari (dalam kes ini, 0) tiada dalam tatasusunan.

Susunan secara ringkas

• Ciri-ciri penting tatasusunan: jenis data yang diletakkan di dalamnya, namanya dan panjangnya.
  Sifat terakhir ditentukan apabila tatasusunan dibuat (apabila memori diperuntukkan untuk tatasusunan). Dua sifat pertama ditentukan apabila tatasusunan diisytiharkan.

• Saiz tatasusunan (bilangan sel) mestilah int

• Adalah mustahil untuk menukar panjang tatasusunan selepas ia dibuat.

• Elemen tatasusunan boleh diakses oleh indeksnya.

• Elemen dalam tatasusunan, seperti semua yang lain di Jawa, dinomborkan bermula dari sifar.

• Selepas tatasusunan dibuat, ia diisi dengan nilai lalai.

• Tatasusunan dalam Java tidak sama dengan tatasusunan dalam C++. Mereka hampir seperti penunjuk kepada tatasusunan dinamik.

Bahan berguna tentang tatasusunan

Ingin mengetahui lebih lanjut tentang tatasusunan? Semak artikel di bawah. Terdapat banyak bahan yang menarik dan berguna mengenai topik ini.