Kelas tatasusunan, bahagian 2

1.Arrays.fill()

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 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);

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.

Contoh:

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

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


String str = Arrays.toString(x);

"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

Kaedah ini Arrays.fill()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.

2.Arrays.copyOf()

Seperti yang anda sedia maklum, anda tidak boleh mengubah saiz tatasusunan selepas ia dibuat.

Tetapi bagaimana jika anda benar-benar mahu?

Nah, jika anda benar-benar mahu, maka anda boleh!

• Buat tatasusunan baharu dengan panjang yang diingini
• Salin semua elemen dari tatasusunan pertama ke dalamnya.

By the way, inilah yang Arrays.copyOf()dilakukan oleh kaedah itu. Ini adalah apa yang memanggilnya kelihatan seperti:

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

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

Jika elemen tidak sesuai (panjangnya kurang daripada panjang tatasusunan sedia ada ), maka nilai tambahan diabaikan.

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);

"[1, 2, 3, 4, 5]"

"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

Dan bagaimana jika anda ingin mendapatkan tatasusunan panjang 5 daripada tatasusunan panjang 10, tetapi anda memerlukannya mengandungi 5 elemen terakhir dan bukannya 5 yang pertama?

Dalam kes ini, kaedah kelas lain Arraysakan berguna - Arrays.copyOfRange(). Inilah rupanya apabila kita memanggilnya:

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

Kaedah ini juga mencipta tatasusunan baharu, tetapi mengisinya dengan elemen dari tempat sewenang-wenangnya dalam tatasusunan asal. Di mana pertama dan terakhir ialah indeks bagi elemen pertama dan terakhir yang harus dimasukkan ke dalam tatasusunan baharu.

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);

"[16, 17, 18, 19, 20]"

"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

Ah, hidangan yang paling lazat: menyusun . Tatasusunan disusun agak kerap dalam pengaturcaraan. Tiga tindakan yang paling biasa apabila bekerja dengan tatasusunan ialah:

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

Inilah sebabnya pencipta Java menyertakan sort()kaedah dalam Arrayskelas. Ini adalah apa yang memanggilnya kelihatan seperti:

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);

"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Cemerlang, bukan? Anda memanggil satu kaedah, dan kini anda mempunyai tatasusunan yang diisih. Cantik.

Dengan cara ini, anda boleh menggunakan kaedah ini untuk mengisih bukan sahaja keseluruhan tatasusunan, tetapi hanya sebahagian daripadanya. Ini adalah apa yang memanggilnya kelihatan seperti:

Arrays.sort(name, first, last);

Di mana pertama dan terakhir ialah indeks sel pertama dan terakhir yang harus disentuh oleh jenis itu.

Contoh:

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

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

"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

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 3,000 perbandingan elemen tatasusunan. Mengisih tatasusunan satu juta elemen akan melibatkan kira-kira 6 juta perbandingan.

5.Arrays.binarySearch()

Nah, dan kaedah terakhir yang paling menarik dalam kelas Arraysdapat mencari nilai tertentu dalam tatasusunan. Ini bukan carian biasa — ia adalah carian binari yang disayangi . 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.

Kerana tatasusunan diisih, adalah mungkin untuk menghapuskan separuh daripadanya dalam satu perbandingan. Kemudian dalam langkah seterusnya, kami melemparkan separuh lagi, dan seterusnya.

Pendekatan ini menjadikan carian binari sangat pantas. Dalam tatasusunan satu juta (!) elemen, ia boleh mencari indeks elemen yang dikehendaki dalam hanya 20 perbandingan. Kelemahan pendekatan ini 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 Arrays.sort()kaedah). Dan valueadalah elemen 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);

{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

Jika tatasusunan mengandungi berbilang contoh elemen yang sedang dicari, maka algoritma hanya akan mengembalikan indeks salah satu daripadanya (tiada jaminan bahawa ia akan menjadi, katakan, yang pertama, atau sebaliknya — yang terakhir daripada ini elemen pendua)."

Jika elemen tidak ditemui dalam tatasusunan, maka indeks akan menjadi negatif.

6. Pautan ke dokumentasi Oracle pada Arrayskelas

Jika anda sangat berminat, anda boleh membaca segala-galanya tentang Arrayskelas dan semua kaedahnya dalam dokumentasi rasmi a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">di tapak web Oracle.

Sebagai contoh, anda boleh membaca tentang Arrays.mismatch()dan Arrays.compare()kaedah. Mungkin anda akan mendapati mereka berguna entah bagaimana.

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