Tatasusunan di Jawa

Bayangkan sel dalam bilik simpanan. Setiap satu mempunyai nombor sendiri, dan setiap satu mengandungi beberapa jenis objek "Bagasi". Atau senarai wain, di mana semua jenis wain dinomborkan dan apabila anda membuat pesanan, anda hanya perlu memberikan nombor minuman. Atau senarai pelajar dalam kumpulan, di mana pelajar "Andreev" akan ditulis dalam sel pertama, dan "Yakovlev" dalam sel terakhir. Atau senarai penumpang kapal terbang, yang masing-masing diberikan tempat duduk dengan nombor tertentu. Di Jawa, untuk bekerja dengan struktur yang serupa, iaitu, banyak data homogen, tatasusunan di Jawa sering digunakan.

Apakah array?

Tatasusunan ialah struktur data yang menyimpan elemen dari jenis yang sama. Ia boleh dianggap sebagai satu set sel bernombor, setiap satunya boleh mengandungi beberapa data (satu elemen data setiap sel). Akses kepada sel tertentu dilakukan melalui nombornya. Bilangan elemen dalam tatasusunan juga dipanggil indeks . Dalam kes Java, tatasusunan adalah homogen, iaitu, semua selnya akan menyimpan elemen dari jenis yang sama. Jadi, tatasusunan integer hanya mengandungi integer (contohnya, jenis int ), tatasusunan rentetan hanya mengandungi rentetan, tatasusunan elemen kelas Dog yang kami buat hanya akan mengandungi objek Dog . Iaitu, dalam Java kita tidak boleh meletakkan integer dalam sel pertama tatasusunan, String dalam kedua , dan "anjing" dalam ketiga.

Pengisytiharan Array

Bagaimana untuk mengisytiharkan tatasusunan?

Seperti mana-mana pembolehubah, tatasusunan dalam Java mesti diisytiharkan. Anda boleh melakukan ini dalam satu daripada dua cara. Mereka adalah setara, tetapi yang pertama lebih konsisten dengan gaya Java. Yang kedua ialah warisan bahasa C (banyak pengaturcara C beralih ke Java, dan untuk kemudahan mereka kaedah alternatif ditinggalkan). Jadual menunjukkan kedua-dua cara untuk mengisytiharkan tatasusunan dalam Java: Dalam kedua-dua kes, dataType ialah jenis pembolehubah dalam tatasusunan. Dalam contoh kami mengisytiharkan dua tatasusunan. Satu akan menyimpan integer jenis int , satu lagi akan menyimpan objek jenis Object . Oleh itu, apabila tatasusunan diisytiharkan, ia mempunyai nama dan jenis (jenis pembolehubah tatasusunan). arrayName ialah nama array.

Mencipta Array

Bagaimana untuk membuat tatasusunan?

Seperti mana-mana objek lain, anda boleh mencipta tatasusunan Java, iaitu, simpan ruang memori untuknya, menggunakan operator baharu . Ini dilakukan seperti ini:

new typeOfArray [length];

Di mana typeOfArray ialah jenis tatasusunan, dan panjang ialah panjangnya (iaitu, bilangan sel), dinyatakan dalam integer ( int ). Walau bagaimanapun, di sini kami hanya memperuntukkan memori untuk tatasusunan, tetapi tidak mengaitkan tatasusunan yang dibuat dengan mana-mana pembolehubah yang diisytiharkan sebelum ini. Biasanya tatasusunan pertama kali diisytiharkan dan kemudian dibuat, sebagai contoh:

int[] myArray; // array declaration
myArray = new int[10]; // creation, that is, allocation of memory for an array of 10 elements of type int

Di sini kami mengisytiharkan tatasusunan integer yang dipanggil myArray , dan kemudian mengisytiharkan bahawa ia terdiri daripada 10 sel (setiap satunya akan menyimpan integer). Walau bagaimanapun, adalah lebih biasa untuk mencipta tatasusunan sejurus selepas pengisytiharan menggunakan sintaks singkatan ini:

int[] myArray = new int[10]; // declaration and allocation of memory "in one bottle"

Catatan:Selepas mencipta tatasusunan menggunakan new , selnya diisi dengan nilai lalai. Untuk jenis angka (seperti dalam contoh kami) ini akan menjadi 0, untuk boolean - false , untuk jenis rujukan - null . Oleh itu, selepas pembedahan

int[] myArray = new int[10];

kita mendapat tatasusunan sepuluh integer, dan sehingga ini berubah semasa program, setiap sel mengandungi 0.

Panjang tatasusunan di Jawa

Seperti yang kita katakan di atas, panjang tatasusunan ialah bilangan elemen yang mana tatasusunan itu direka bentuk. Panjang tatasusunan tidak boleh diubah setelah ia dibuat. Catatan:Di Java, elemen tatasusunan dinomborkan bermula dari sifar. Iaitu, jika kita mempunyai tatasusunan 10 elemen, maka elemen pertama tatasusunan akan mempunyai indeks 0, dan yang terakhir akan mempunyai indeks 9. Anda boleh mengakses panjang tatasusunan menggunakan pembolehubah panjang . Contoh:

int[] myArray = new int[10]; // created an array of integers with 10 elements and named it myArray
System.out.println(myArray.length); // printed to the console the length of the array, that is, the number of elements that we can put in the array

Output program:

Memulakan tatasusunan dan mengakses elemennya

Cara membuat tatasusunan dalam Java sudah jelas. Selepas prosedur ini, kami tidak mendapat tatasusunan kosong, tetapi tatasusunan yang diisi dengan nilai lalai. Sebagai contoh, dalam kes int ini akan menjadi 0, dan jika kita mempunyai tatasusunan dengan data jenis rujukan, maka secara lalai, null ditulis dalam setiap sel . Kami mengakses elemen tatasusunan (iaitu, kami menulis nilai ke dalamnya atau memaparkannya pada skrin atau melakukan beberapa operasi dengannya) dengan indeksnya. Memulakan tatasusunan ialah mengisinya dengan data tertentu (bukan secara lalai). Contoh: mari buat susunan 4 musim dan isi dengan nilai rentetan - nama musim ini.

String[] seasons  = new String[4]; /* declared and created an array. Java allocated memory for an array of 4 strings, and now each cell is null (because the string is a reference type)*/

seasons[0] = "Winter"; /* in the first cell, that is, in the cell with a zero number, we wrote the string Winter. Here we get access to the zero element of the array and write a specific value there */
seasons[1] = "Spring"; // do the same procedure with cell number 1 (second)
seasons[2] = "Summer"; // ...number 2
seasons[3] = "Autumn"; // and with the last one, number 3

Kini keempat-empat sel tatasusunan kami mengandungi nama musim. Permulaan juga boleh dilakukan secara berbeza, menggabungkan pemulaan dan pengisytiharan:

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

Selain itu, pengendali baharu boleh ditinggalkan:

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

Bagaimana untuk memaparkan tatasusunan dalam Java pada skrin?

Anda boleh memaparkan elemen tatasusunan pada skrin (iaitu, ke konsol), contohnya, menggunakan gelung for . Satu lagi cara yang lebih pendek untuk memaparkan tatasusunan pada skrin akan dibincangkan dalam perenggan "Kaedah berguna untuk bekerja dengan tatasusunan" di bawah. Buat masa ini, mari lihat contoh dengan keluaran kitaran tatasusunan:

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

Akibatnya, program akan mengeluarkan hasil berikut:

Tatasusunan Java satu dimensi dan pelbagai dimensi

Bagaimana jika kita tidak mahu mencipta tatasusunan nombor, tatasusunan rentetan, atau tatasusunan beberapa objek, tetapi tatasusunan tatasusunan? Java membolehkan anda melakukan ini. Tatasusunan yang sudah biasa int[] myArray = new int[8] ialah tatasusunan satu dimensi yang dipanggil. Dan tatasusunan tatasusunan dipanggil dua dimensi. Ia seperti jadual yang mempunyai nombor baris dan nombor lajur. Atau, jika anda mempelajari permulaan algebra linear, pada matriks. Mengapa tatasusunan sedemikian diperlukan? Khususnya, untuk pengaturcaraan matriks dan jadual yang sama, serta objek yang menyerupainya dalam struktur. Sebagai contoh, medan permainan untuk catur boleh ditentukan sebagai tatasusunan 8x8. Tatasusunan berbilang dimensi diisytiharkan dan dibuat seperti berikut:

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

Terdapat tepat 64 elemen dalam tatasusunan ini: 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 sel A1 akan mewakili myTwoDimentionalArray[0][0], dan E2 akan mewakili myTwoDimentionalArray[4][1]. Di mana ada dua, ada tiga. Di Jawa, anda boleh menentukan tatasusunan tatasusunan... tatasusunan tatasusunan, dan sebagainya. Benar, tatasusunan tiga dimensi dan lebih banyak digunakan sangat jarang. Walau bagaimanapun, menggunakan tatasusunan tiga dimensi, anda boleh memprogram, sebagai contoh, kiub Rubik.

Kaedah berguna untuk bekerja dengan tatasusunan

Untuk bekerja dengan tatasusunan dalam Java terdapat kelas java.util.Arrays (tatasusunan dalam bahasa Inggeris bermaksud "tatasusunan"). Secara umum, operasi berikut paling kerap dilakukan dengan tatasusunan: mengisi dengan elemen (permulaan), mendapatkan semula elemen (mengikut nombor), menyusun dan mencari. Mencari dan menyusun tatasusunan ialah topik yang berasingan. Di satu pihak, sangat berguna untuk berlatih dan menulis beberapa algoritma carian dan pengisihan sendiri. Sebaliknya, semua amalan terbaik telah pun ditulis dan dimasukkan ke dalam perpustakaan Java, dan boleh digunakan secara sah. Berikut ialah tiga kaedah berguna kelas ini

Isih tatasusunan

Kaedah ini void sort(int[] myArray, int fromIndex, int toIndex)menyusun tatasusunan integer atau subarraynya dalam tertib menaik.

Mencari tatasusunan untuk elemen yang dikehendaki

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key). Kaedah ini mencari elemen utama dalam myArray atau subarray yang telah diisih , bermula dari fromIndex dan berakhir ke toIndex . Jika elemen ditemui, kaedah mengembalikan indeksnya, jika tidak - . (-fromIndex)-1

Menukar Tatasusunan kepada Rentetan

Kaedah String toString(int[] myArray)menukar tatasusunan kepada rentetan. Masalahnya ialah dalam tatasusunan Java tidak mengatasi toString() . Ini bermakna jika anda cuba memaparkan keseluruhan tatasusunan (bukan elemen demi elemen, seperti dalam " Mencetak Tatasusunan ke Skrin ") ke skrin secara terus ( System.out.println(myArray)), anda akan mendapat nama kelas dan kod cincangan heksadesimal tatasusunan (ini ditakrifkan oleh Object.toString() ). Jika anda seorang pemula, anda mungkin tidak memahami penjelasan kaedah tersebut toString. Pada peringkat pertama ini tidak perlu, tetapi menggunakan kaedah ini output tatasusunan dipermudahkan. Java memudahkan untuk memaparkan tatasusunan tanpa menggunakan gelung. Lebih lanjut mengenai ini dalam contoh di bawah.

Contoh pada isihan, binarySearch dan toString

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

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; //declaring and initializing the array
        System.out.println(array);//trying to display our array on the screen without the toString method - we get a hexadecimal number
        System.out.println(Arrays.toString(array));//печатаем массив "правильно"
        Arrays.sort(array, 0, 4); // sort the entire array from zero to the fourth member
        System.out.println(Arrays.toString(array));//print the sorted array to the screen
        int key = Arrays.binarySearch(array, 5); // ищем key - число 5 в отсортированном массиве.
        //binarySearch method will return the index of the sorted array element, in which the required number is "hidden"
        System.out.println(key);//распечатываем индекс искомого числа
System.out.println(Arrays.binarySearch(array, 0));//а теперь попробуем найти число, которого в массиве нет,
        // and immediately display the result on the screen

    }
}

Output program: Baris pertama ialah percubaan untuk memaparkan tatasusunan tanpa toString , yang kedua memaparkan tatasusunan menggunakan toString , yang ketiga ialah tatasusunan yang diisih, yang keempat ialah indeks nombor 5 yang dikehendaki dalam tatasusunan yang diisih (ingat bahawa kita mengira dari sifar, jadi elemen keempat tatasusunan mempunyai indeks 3). Dalam baris kelima kita melihat nilai -1 . Tatasusunan tidak mempunyai indeks sedemikian. Output memberi isyarat bahawa elemen yang dikehendaki (dalam kes ini, 0) tiada dalam tatasusunan.

Perkara utama mengenai tatasusunan

• Ciri-ciri utama tatasusunan: jenis data yang diletakkan di dalamnya, nama dan panjang.
  Yang terakhir diputuskan semasa permulaan (memperuntukkan memori untuk tatasusunan), dua parameter pertama ditentukan semasa mengisytiharkan tatasusunan.

• Saiz tatasusunan (bilangan sel) mesti ditakrifkan dalam int

• Anda tidak boleh menukar panjang tatasusunan selepas ia dibuat.

• Elemen tatasusunan boleh diakses oleh indeksnya.

• Dalam tatasusunan, seperti di tempat lain di Jawa, elemen dinomborkan bermula dari sifar.

• Selepas prosedur penciptaan tatasusunan, ia diisi dengan nilai lalai.

• Tatasusunan dalam Java distrukturkan secara berbeza daripada dalam C++. Mereka hampir sama dengan penunjuk kepada tatasusunan dinamik.

Bahan berguna tentang tatasusunan

Ingin mengetahui lebih lanjut tentang tatasusunan? Sila lihat artikel di bawah. Terdapat banyak maklumat menarik dan berguna mengenai topik ini.

1. Sesuatu Mengenai Tatasusunan - Artikel terperinci yang bagus tentang tatasusunan

2. Kelas Arrays dan penggunaannya - artikel menerangkan beberapa kaedah kelas Array

3. Tatasusunan berbilang dimensi - artikel terperinci tentang tatasusunan berbilang dimensi dengan contoh.

4. Kembalikan tatasusunan sifar panjang, bukan nol - Pengarang Pengaturcaraan Berkesan Joshua Bloch bercakap tentang cara untuk mengembalikan tatasusunan kosong dengan lebih baik