Kelas tatasusunan, bahagian 2

"Rishi, saya sangat tidak sabar untuk belajar tentang kaedah lain dalam kelas Arrays.

"Kesungguhan untuk belajar tidak boleh tetapi menggembirakan guru lama anda! Tetapi, jika anda benar-benar ingin mengetahui segala-galanya, ahli sihir yang baik hati bernama Google akan membantu anda siang dan malam."

"Eh..."

"Sekadar bergurau. Macam-macam. Sudah tentu, saya akan menerangkan segala-galanya dengan lebih baik, tetapi jika sesuatu muncul - ingat ahli sihir yang baik. Saya akan memulakan pelajaran hari ini dengan Arrays.fillkaedah

"Apabila bekerja dengan tatasusunan, pengaturcara Java selalunya perlu mengisi tatasusunan dengan nilai yang sama. Anda boleh, sudah tentu, menulis gelung dan hanya menetapkan beberapa nilai kepada setiap sel tatasusunan dalam gelung:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

"Atau bukannya semua ini, anda boleh memanggil Arrays.fill()kaedah, yang melakukan perkara yang sama: ia mengisi tatasusunan yang diluluskan dengan nilai yang diluluskan. Begini rupanya:

Arrays.fill(name, value)

Dan kod dalam contoh di atas boleh dibuat sedikit lebih padat dan lebih jelas:

int[] x = new int[100];
Arrays.fill(x, 999);

"Cantik!"

"Anda juga boleh menggunakan Arrays.fill()kaedah untuk mengisi bukan keseluruhan tatasusunan, tetapi sebahagian daripadanya, dengan beberapa nilai:

Arrays.fill(name, first, last, value)

"Di mana pertama dan terakhir adalah indeks sel pertama dan terakhir yang akan diisi.

" Selaras dengan tradisi lama Java yang baik (atau buruk), ingat bahawa elemen terakhir tidak termasuk dalam julat.

Contoh:

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

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

" Arrays.fill()Kaedah ini hanya berfungsi dengan tatasusunan satu dimensi. Jika anda menghantar tatasusunan dua dimensi kepada kaedah, ia akan dianggap sebagai satu dimensi, dengan semua akibat yang berikutnya.

Arrays.copyOf()

"Amigo, sila beritahu saya bagaimana untuk menukar saiz tatasusunan selepas ia telah dibuat?"

"Umm... Itu soalan tipu, kan? Saya bukan tidak berpengalaman lagi. Jawapan yang betul ialah anda tidak boleh! Anda tidak boleh mengubah saiz tatasusunan selepas ia dibuat."

"Tetapi bagaimana jika anda benar-benar mahu?"

"Ia masih mustahil!

"Sebenarnya, jika anda benar-benar mahu, maka anda boleh! Dengan bantuan helah pengaturcaraan:

1. Mula-mula, anda mencipta tatasusunan baharu dengan panjang yang diingini
2. Kemudian anda menyalin semua elemen dari tatasusunan pertama ke dalamnya.

"Ini adalah dua perkara yang Arrays.copyOf()dilakukan oleh kaedah. Ini adalah apa yang memanggilnya kelihatan seperti:

Type[] name2 = Arrays.copyOf(name, length);

"Kaedah ini tidak mengubah tatasusunan sedia ada , sebaliknya mencipta tatasusunan baharu dan menyalin elemen tatasusunan lama ke dalamnya."

"Bagaimana jika panjang tatasusunan baru kurang daripada panjang yang sedia ada ?

"Soalan yang bagus, Amigo! Jika unsur-unsur tidak sesuai, maka nilai tambahan itu diabaikan begitu saja."

"Dan jika, sebaliknya, terdapat sel tambahan, apakah nilai awalnya?

"Jika panjang tatasusunan baharu lebih besar daripada panjang tatasusunan lama, sel akan diisi dengan sifar.

Contoh:

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

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Arrays.copyOfRange()

"Dan bagaimana jika anda ingin mendapatkan tatasusunan panjang 5 daripada tatasusunan panjang 10, tetapi anda memerlukannya untuk mengandungi 5 elemen terakhir dan bukannya 5 yang pertama? Dalam kes ini, anda memerlukan kaedah kelas yang lain. Ia Arraysadalah Arrays.copyOfRange(). Inilah rupa panggilannya:

Type[] name2 = Arrays.copyOfRange(name, first, last);

"Kaedah ini juga mencipta tatasusunan baharu, tetapi mengisinya dengan unsur-unsur dari tempat sewenang-wenangnya dalam tatasusunan asal. Di mana pertama dan terakhir ialah indeks bagi elemen pertama dan terakhir yang perlu dimasukkan ke dalam tatasusunan baharu. Bolehkah anda beritahu saya sama ada elemen terakhir termasuk dalam julat ini?"

"Ha! Seperti yang dikatakan oleh guru besar saya, ' sesuai dengan tradisi lama Jawa yang baik (atau buruk), ingat bahawa elemen terakhir tidak termasuk dalam julat '."

"Amigo, awak semakin membesar di depan mata kami.

Contoh:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Arrays.sort()

"Dan akhirnya, saya meninggalkan yang paling banyak... mmm... kaedah yang menyenangkan untuk yang terakhir: pengisihan . Tatasusunan biasanya diisih dalam pengaturcaraan. Berikut ialah 3 tindakan paling popular apabila bekerja dengan tatasusunan:

• Mengisih tatasusunan
• Mencari elemen minimum (atau maksimum) tatasusunan
• Menentukan indeks unsur dalam tatasusunan (mencari elemen dalam tatasusunan)

"Algoritma pengisihan yang berprestasi baik, mesti saya katakan, tidak begitu mudah untuk ditulis. Lebih tepat lagi, ini adalah tugas standard, dan sebagai pelajar, ia tidak akan merugikan anda untuk berlatih menulis algoritma pengisihan kadang-kadang. Tetapi di tempat kerja, ia adalah lebih baik untuk tidak membuang masa anda mencipta semula roda. Pencipta Java menyertakan kaedah sort()dalam Arrayskelas. Beginilah rupa panggilannya:

Arrays.sort(name);

Kaedah ini mengisih tatasusunan yang diluluskan dalam tertib menaik.

Contoh:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);
String str = Arrays.toString(x);

"Cemerlang! Saya hanya memanggil satu kaedah dan tatasusunan disusun. Satu perkara yang cantik!"

"Omong-omong, anda boleh mengisih bukan sahaja keseluruhan tatasusunan, tetapi juga sebahagian daripadanya. Inilah yang memanggilnya:

Arrays.sort(name, first, last);

"Di mana pertama dan terakhir ialah indeks sel pertama dan terakhir yang jenis itu harus disentuh. DAN…

"Saya sudah tahu apa yang anda akan katakan! 'Selaras dengan tradisi lama Java yang baik (atau buruk), ingat bahawa elemen terakhir tidak termasuk dalam julat' .

Contoh:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"Untuk mengisih tatasusunan, Java menggunakan algoritma pengisihan terpantas — QuickSort . Kerumitan pengiraannya bergantung pada saiz tatasusunan dan dikira menggunakan formula N log(N).

"Mengisih tatasusunan 1000 elemen akan melibatkan kira-kira 10,000 perbandingan elemen tatasusunan. Mengisih tatasusunan satu juta elemen akan melibatkan kira-kira 20 juta perbandingan."

" Tidak terlalu banyak perbandingan apabila anda mempertimbangkan bilangan elemen!"

"Itu betul-betul apa yang saya katakan. Algoritma QuickSort sangat cekap.

Arrays.binarySearch()

"Nah, dan kaedah terakhir yang paling menarik dalam kelas Arraysadalah dapat mencari nilai tertentu dalam tatasusunan. Ini bukan carian biasa — ia adalah carian binari yang digemari . Ia bermuara kepada ini:

• Pertama, tatasusunan diisih.
• Kemudian elemen tengah tatasusunan dibandingkan dengan yang kita cari.
• Jika elemen lebih besar daripada elemen tengah, maka carian diteruskan di separuh kanan tatasusunan.
• Jika elemen yang kita cari adalah kurang daripada elemen tengah, maka carian diteruskan di separuh kiri tatasusunan.

"Oleh kerana tatasusunan diisih, adalah mungkin untuk menghapuskan separuh daripadanya dalam satu perbandingan. Kemudian dalam langkah seterusnya, kita membuang separuh lagi, dan seterusnya."

"Hebat! Kami bergerak terus ke gawang dengan cepat!"

"Tepat sekali. Dalam tatasusunan satu juta (!) elemen, algoritma carian binari boleh mencari indeks elemen yang dikehendaki dalam hanya 20 perbandingan. Kelemahan algoritma ialah tatasusunan mesti diisih terlebih dahulu, dan pengisihan juga mengambil masa.

Ini adalah apa yang memanggilnya kelihatan seperti:

int index = Arrays.binarySearch(name, value);

"Di manakah namenama tatasusunan, yang mesti diluluskan sudah diisih (contohnya, menggunakan kaedah Arrays.sort()). Dan valueelemen yang kita cari dalam tatasusunan. Hasil yang dikembalikan oleh kaedah ialah indeks elemen tatasusunan yang dikehendaki .

Contoh:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

"Bagaimana jika elemen yang dikehendaki muncul beberapa kali dalam tatasusunan ?"

"Itu soalan yang sah, Amigo. Dalam kes ini, algoritma akan mengembalikan indeks salah satu daripadanya (tiada jaminan bahawa ia akan menjadi, katakan, yang pertama, atau sebaliknya — yang terakhir bagi elemen pendua ini) ."

"Bagaimana jika tatasusunan tidak mengandungi elemen yang diingini sama sekali?"

"Dalam kes ini, algoritma akan mengembalikan indeks negatif .

Dokumentasi

"Semuanya jelas, Rishi! Ini sangat menarik."

"Sekiranya anda benar-benar mendapati ini sangat menarik, maka pada masa lapang anda semak dokumentasi rasmi kelas Arraysdan kaedahnya di laman web Oracle .

"Anda boleh melihat dengan lebih dekat, sebagai contoh, kaedah Arrays.mismatch()dan Arrays.compare()kaedah. Anda kemungkinan besar akan dapat menggunakannya dengan baik.

"Dan jangan keliru dengan bilangan kaedah. Setiap kaedah mempunyai 5-10 varian, yang berbeza hanya dalam jenis parameternya."