Sesuai kesepakatan, ketika menggunakan pemrograman Java, Anda harus menggunakan perpustakaan kelas yang ada sebanyak mungkin, tentu saja, Anda juga dapat menulis sendiri metode atau kerangka pengurutan, tetapi berapa banyak orang yang dapat menulis lebih baik daripada yang ada di JDK? Manfaat lain menggunakan kelas yang ada adalah kodenya mudah dibaca dan dipelihara. Artikel ini terutama membahas tentang cara menggunakan perpustakaan kelas yang ada untuk mengurutkan array dan berbagai wadah Koleksi (Beberapa contoh dalam artikel berasal dari "Java Developers Almanac 1.4》 )
Pertama-tama, Anda perlu mengetahui dua kelas: java.util.Arrays dan java.util.Collections (perhatikan perbedaannya dengan Collection) Collection adalah antarmuka tingkat atas dari kerangka koleksi, dan Koleksi berisi banyak metode statis. Kami menggunakan Array untuk mengurutkan array dan Koleksi untuk mengurutkan wadah bingkai gabungan, seperti ArraysList, LinkedList, dll.
Impor java.util.* dan kode shell lainnya, seperti kelas dan metode utama statis, harus ditambahkan ke contoh. Saya akan menulis semua kode pada contoh pertama, dan akan menghilangkannya tanpa kecuali pada contoh berikut.
Urutkan susunan
Misalnya, ada array bilangan bulat:
Copy kode kodenya sebagai berikut:
int[] intArray = int baru[] {4, 1, 3, -23};
Bagaimana kita mengurutkannya? Apakah Anda sedang memikirkan algoritma pengurutan cepat saat ini? Lihatlah bagaimana hal ini dilakukan:
Copy kode kodenya sebagai berikut:
import java.util.*;
Sortir kelas publik{
public static void main(String[] args){
int[] intArray = int baru[] {4, 1, 3, -23};
Array.sort(intArray);
}
}
Dengan cara ini, kita menggunakan metode statis sort() dari Array untuk mengurutkan intArray dalam urutan menaik, dan sekarang array menjadi {-23,1,3,4}.
Jika itu adalah array karakter:
Copy kode kodenya sebagai berikut:
String[] strArray = String baru[] {"z", "a", "C"};
Kami menggunakan:
Copy kode kodenya sebagai berikut:
Array.sort(strArray);
Hasil setelah pengurutan adalah {C, a, z}, dan sort() akan mengurutkan dalam urutan menaik sesuai dengan urutan alami elemen. Jika Anda ingin membedakan huruf besar-kecil, Anda dapat menulis:
Copy kode kodenya sebagai berikut:
Array.sort(strArray, String.CASE_INSENSITIVE_ORDER);
Tentu saja, kita juga dapat menentukan bagian tertentu dari array untuk diurutkan. Misalnya, jika kita ingin mengurutkan bagian 0-2 dari array (dengan asumsi panjang array lebih besar dari 3), dan bagian lainnya tetap tidak berubah, kita juga dapat menentukan bagian tertentu dari array untuk diurutkan. dapat menggunakan:
Copy kode kodenya sebagai berikut:
Array.sort(strArray,0,2);
Dengan cara ini, kita hanya mengurutkan tiga elemen pertama tanpa mempengaruhi bagian berikutnya.
Tentu sebagian orang akan berpikir, bagaimana cara mengurutkan secara descending? Di antara sekian banyak metode pengurutan, salah satu salinan kodenya adalah sebagai berikut:
sortir(T[] a, Pembanding<? super T> c)
Kita bisa menggunakan Comparator untuk mendapatkan comparator dalam urutan terbalik. Comparator akan dijelaskan nanti. Ambil intArray[] sebelumnya sebagai contoh:
Copy kode kodenya sebagai berikut:
Array.sort(intArray,Comparator.reverseOrder());
Dengan cara ini, hasil yang kita peroleh adalah {4,3,1,-23}. Jika kita tidak ingin mengubah kode aslinya kita juga dapat menggunakan:
Copy kode kodenya sebagai berikut:
Koleksi.reverse(Arrays.asList(intArray));
Dapatkan urutan kebalikan dari array. Hasilnya juga 4,3,1,-23}.
Sekarang situasinya telah berubah. Array kita bukan lagi array dengan tipe data primitif (tipe primitif) atau tipe String, tetapi array objek. Urutan alami dari array ini tidak diketahui, jadi kita perlu mengimplementasikan antarmuka Comparable untuk kelas ini.
Copy kode kodenya sebagai berikut:
Nama kelas mengimplementasikan Comparable<Name>{
String publik Nama Depan, Nama Belakang;
Nama publik(String Nama Depan, String Nama Belakang){
this.firstName=Namadepan;
ini.NamaBelakang=NamaBelakang;
}
public int bandingkanTo(Nama o) {//Menerapkan antarmuka
int lastCmp=lastName.compareTo(o.lastName);
return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));
}
public String toString(){ //Nyaman untuk pengujian keluaran
kembalikan Nama Depan+" "+Nama Belakang;
}
}
Dengan cara ini, saat kita mengurutkan array objek ini, pertama-tama kita akan membandingkan Nama Belakang, lalu membandingkan Nama Depan, lalu mendapatkan urutan kedua objek tersebut, seperti yang diterapkan di bandingkanTo(Nama o). Anda sebaiknya mencobanya dengan program ini:
Copy kode kodenya sebagai berikut:
import java.util.*;
kelas publik NameSort {
public static void main(String[] args) {
Nama namaArray[] = {
Nama baru("John", "Lennon"),
nama baru("Karl", "Marx"),
Nama baru("Groucho", "Marx"),
Nama baru("Oscar", "Penggerutu")
};
Array.sort(namaArray);
for(int i=0;i<namaArray.panjang;i++){
Sistem.keluar.println(namaArray[i].toString());
}
}
}
Hasilnya seperti yang kami harapkan:
Copy kode kodenya sebagai berikut:
Oscar Penggerutu
John Lennon
Groucho Marx
Karl Marx
Urutkan bingkai koleksi
Jika Anda sudah memahami Arrays.sort() untuk mengurutkan array, penggunaan framework koleksi serupa. Ganti saja Array dengan Koleksi. Perhatikan bahwa Koleksi adalah kelas dan Koleksi adalah antarmuka. Meskipun hanya ada satu perbedaan "s", artinya sangat berbeda.
Misalkan ada daftar tertaut seperti ini:
Copy kode kodenya sebagai berikut:
Daftar LinkedList=LinkedList baru();
daftar.tambahkan(4);
daftar.tambahkan(34);
daftar.tambahkan(22);
daftar.tambahkan(2);
Kita hanya perlu menggunakan:
Copy kode kodenya sebagai berikut:
Koleksi.sort(daftar);
Anda dapat mengurutkan elemen di ll dari kecil ke besar, dan hasilnya menjadi:
Copy kode kodenya sebagai berikut:
[2, 4, 22, 34]
Jika elemen dalam LinkedList adalah String, elemen tersebut juga akan diurutkan dari kecil ke besar seperti tipe data dasar.
Jika Anda ingin menerapkan pengurutan terbalik, yaitu dari penyortiran menjangkau ke kecil:
Copy kode kodenya sebagai berikut:
Koleksi.sort(daftar,Collectons.reverseOrder());
Jika elemen dalam LinkedList adalah objek khusus, Anda dapat mengimplementasikan antarmuka Comparable seperti objek Name di atas, lalu biarkan Collection.sort() mengurutkannya untuk Anda.
Jika Anda ingin mengurutkan suatu objek sesuai dengan ide Anda sendiri, Anda dapat menggunakan kode yang disalin sebagai berikut:
sortir(Daftar<T> daftar, Pembanding<? super T> c)
Metode ini melakukan pengurutan. Sebelum memberikan contoh, pertama-tama kita harus menjelaskan penggunaan Comparator dan format antarmuka Comparable:
Copy kode kodenya sebagai berikut:
antarmuka publik Pembanding<T> {
int bandingkan(T o1, T o2);
}
Sebenarnya cara penulisan int bandingkan(T o1,T o2) di Comparator mirip dengan cara penulisan metode bandingkanTo() di Comparable. Di kelas Nama di atas, perbandingan kami dimulai dari Nama Belakang. Ini adalah kebiasaan orang Barat. Di Cina, kami ingin memulai perbandingan dari fristName tanpa mengubah kode aslinya.
Copy kode kodenya sebagai berikut:
Pembanding<Nama> akhir FIRST_NAME_ORDER=Pembanding baru<Nama>() {
public int bandingkan(Nama n1, Nama n2) {
int firstCmp=n1.firstName.compareTo(n2.firstName);
kembali (firstCmp!=0?firstCmp:n1.lastName.compareTo
(n2.Nama Depan));
}
};
Dengan cara ini, Komparator kami yang disesuaikan FIRST_NAME_ORDER ditulis.
Ubah array nama pada contoh sebelumnya menjadi Daftar:
Copy kode kodenya sebagai berikut:
Daftar<Nama> daftar=Array.asList(namaArray);
Koleksi.sort(daftar,FIRST_NAME_ORDER);
Dengan cara ini, kami berhasil mengatur pengurutan menggunakan pembanding yang kami tentukan sendiri.