Hello lagi! :) Dalam pelajaran hari ini, kita akan bercakap tentang kelas Array di Jawa. Dalam pelajaran lepas, kita telah mengetahui struktur data sedemikian yang dipanggil tatasusunan. Kami belajar cara menciptanya dan mengisinya dengan data. Dan kami melihat bagaimana ia disimpan dalam ingatan. Hari ini kita akan melihat beberapa tugasan dan contoh bekerja dengan tatasusunan yang sering anda lihat dalam kerja sebenar. Sebagai contoh, bayangkan situasi ini: Kami mempunyai tatasusunan 10 nombor rawak.
Tugas kita ialah menyusun tatasusunan ini dalam tertib menaik: daripada terkecil kepada terbesar. Pada akhirnya, ia sepatutnya kelihatan seperti ini: [-234, -2, 16, 26, 35, 43, 92, 99, 167] Bagaimanakah kita melakukannya? Tugas ini bukan perkara remeh. Kami tidak pernah melakukan ini sebelum ini :/ Ada idea? Cuba teka. Inilah satu penyelesaian:
Pergi melalui semua elemen tatasusunan. Bandingkan setiap elemen dengan yang seterusnya ([0] dengan [1], [1] dengan [2], [2] dengan [3], dsb.). Jika elemen semasa lebih besar daripada yang seterusnya, kami menukarnya, dan kemudian beralih ke elemen seterusnya. Jika tidak, biarkan mereka seadanya, dan teruskan
Oleh itu, selepas laluan pertama melalui elemen, nilai terbesar (167) dijamin berada dalam sel terakhir.
Sekarang kita akan meneliti semua elemen sekali lagi, tetapi kali ini kita akan mulakan dengan indeks [0] kepada elemen kedua terakhir (bilangan terbesar sudah ada di tempatnya) dan membuat perbandingan dan pertukaran yang sama. Selepas pas ini, dalam sel kedua terakhir, kita akan mempunyai nilai kedua terbesar (99).
Ulangi proses ini seberapa banyak yang kita mempunyai elemen tatasusunan.
Kami ada idea. Sekarang kita hanya perlu menulis kod. Ia kelihatan seperti ini:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
for (int i = numbers.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
/* Compare the elements in pairs.
If they are not in the right order,
then swap them */
if (numbers[j] > numbers[j + 1]) {
int tmp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = tmp;
}
}
}
}
}
Uh ... Nampak agak rumit -_- Walaupun prinsip umum boleh difahami, kita masih perlu menulis kod yang agak banyak untuk menyelesaikan tugasan yang begitu mudah. Baiklah, mungkin kita hanya melebihkan diri kita sendiri? Tugas yang telah kami tangani mungkin masih terlalu rumit untuk kami. Mari cuba sesuatu yang lebih mudah. Sebagai contoh, ambil tatasusunan nombor yang sama.
Tugas kami ialah menyalin kandungannya ke tatasusunan lain.
int [] numbersCopy = new int[10];
Fikirkan bagaimana anda akan melakukannya menggunakan apa yang anda sudah tahu tentang tatasusunan? Sebagai contoh, anda boleh melalui tatasusunan nombor dalam gelung dan secara berurutan menulis elemennya ke dalam numbersCopy :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = new int[10];
for (int i = 0; i < numbers.length; i++) {
numbersCopy[i] = numbers[i];
}
}
}
Nah, eh, di sini pada dasarnya kita telah melakukannya! Nampaknya kami telah menyelesaikan masalah itu. Walau bagaimanapun, jika anda perlu melakukan ini dengan kerap, kod anda akan mempunyai sekumpulan gelung yang sama. Sebenarnya, tugas ini (dan lain-lain) telah lama diselesaikan oleh pencipta Java. Kami tidak perlu "mencipta semula roda" dan mengodkan penyelesaian kami sendiri. Terdapat kelas statik khas ( Arrays ) untuk membantu anda melaksanakan tugas biasa apabila bekerja dengan tatasusunan. Kaedah untuk melaksanakan tugas paling biasa yang dihadapi oleh pengaturcara Java telah ditambahkan pada kelas ini. Sebagai contoh, tugas menyusun tatasusunan, yang kami cuba kendalikan, diselesaikan dalam satu baris:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));
}
}
Kaedah Arrays.sort () mengisih tatasusunan. Dan algoritmanya jauh lebih cekap daripada kod yang kami tulis. Output konsol: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Nota: Untuk menukar tatasusunan kepada rentetan, kami menggunakan kaedah lain bagi kelas Tatasusunan : Arrays.toString() . Tatasusunan dalam Java tidak mengatasi kaedah toString() sendiri. Jadi, jika anda hanya menulis
System.out.println(numbers.toString());
toString() kelas Objek akan dipanggil. Untuk tatasusunan, output akan menjadi seperti ini: [I@4554617c Kami tidak akan menjelaskan secara terperinci sekarang tentang mengapa sebenarnya ini adalah output. Perkara utama ialah ia jelas bukan apa yang kita perlukan. Tetapi Arrays.toString() melakukan dengan tepat apa yang kita mahu. Dengan cara ini, penyalinan juga mudah dicapai dengan kelas Arrays :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println(Arrays.toString(numbersCopy));
}
}
Kami menghantar kepada kaedah Arrays.copyOf() tatasusunan asal kami (yang mana kami ingin menyalin nilai) dan panjang tatasusunan baharu tempat kami menyalin data. Dalam kes ini, kami menunjukkan nombor.panjang sebagai panjang, kerana ingin menyalin keseluruhan tatasusunan. Jika kita mahu menyalin hanya beberapa elemen pertama, kita boleh menentukan panjang tatasusunan baru yang lebih kecil:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, 4);
System.out.println(Arrays.toString(numbersCopy));
}
}
Di sini kami menentukan 4 sebagai panjang tatasusunan baharu. Sehubungan itu, hanya 4 elemen nombor pertama akan disalin ke tatasusunan baharu. Output konsol: [167, -2, 16, 99] By the way, Tatasusunan juga membenarkan anda menyalin sebahagian tatasusunan dari tengah dan bukannya permulaan tatasusunan:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
System.out.println(Arrays.toString(numbersCopy));
}
}
Output: [16, 99, 26, 92] Nombor telah disalin ke dalam tatasusunan baharu daripada tatasusunan kedua daripada elemen kedua (inklusif) hingga unsur keenam (tidak termasuk). Kita juga mungkin perlu membandingkan dua tatasusunan. Seperti kaedah toString() , tatasusunan sendiri tidak mengatasi kaedah equals() . Jadi jika kita cuba membandingkan mereka seperti ini
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(numbers.equals(numbers2));
}
}
maka kita mendapat palsu. Ini kerana Object.equals() , yang membandingkan rujukan, akan dipanggil. Dan, jelas sekali, mereka berbeza! Tetapi apa yang kita perlukan ialah membandingkan kandungan tatasusunan, bukan rujukan. Kelas Arrays mengatasi kaedah equals() untuk menjadikannya melakukan apa yang kita mahukan:
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(Arrays.equals(numbers, numbers2));
}
}
Output: true Dengan cara ini, kelas Arrays berfungsi bukan sahaja dengan tatasusunan biasa, tetapi juga dengan tatasusunan dua dimensi:
public class Main {
public static void main(String[] args) {
int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println("Are these two-dimensional arrays equal?");
System.out.println(Arrays.deepEquals(numbers, numbersCopy));
System.out.println(Arrays.deepToString(numbersCopy));
}
}
Output: Adakah tatasusunan dua dimensi ini sama? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Seperti yang anda lihat, kaedah Arrays.copyOf() dapat menyalin tatasusunan dua dimensi. Dan kelas mempunyai kaedah khas untuk membandingkan dan memaparkan tatasusunan dua dimensi: deepEquals dan deepToString() . Pada masa hadapan, anda akan berulang kali melihat (dan bergembira kerana) bahawa pencipta Java menjangkakan banyak situasi yang sering dihadapi oleh pengaturcara, dan melaksanakan penyelesaian sedia untuk mereka dalam bahasa tersebut. Menggunakan penyelesaian ini adalah lebih mudah dan lebih mudah daripada mencipta semula roda, bukan? :) Pastikan anda membaca dokumentasi untuk kelas Arrays di laman web Oracle . Semoga berjaya dalam pelajaran!
GO TO FULL VERSION