Pembanding, menyortir koleksi

"Hai, Amigo!"

"Hai, Bilaabo!"

"Hari ini kita akan membahas topik kecil, tapi menarik dan bermanfaat: menyortir koleksi."

"Menyortir? Aku pernah mendengar sesuatu tentang itu."

"Dulu, setiap pemrogram harus bisa menulis algoritme pengurutan. Mampu dan harus menulisnya. Tapi hari-hari itu sudah berakhir. Saat ini, menulis kode pengurutan Anda sendiri dianggap bentuk yang buruk, sama seperti menulis ulang hal lain yang sudah telah ditemukan."

"Di Java (dan bahasa pemrograman lainnya), penyortiran sudah diterapkan.  Tugas Anda adalah mempelajari cara menggunakan apa yang sudah ada dengan benar. "

"OKE."

" Kelas pembantu Koleksi memiliki metode pengurutan statis yang digunakan untuk mengurutkan koleksi—atau lebih tepatnya, daftar. Elemen di Peta dan Set tidak memiliki urutan/indeks, jadi tidak ada yang perlu diurutkan."

"Ya, saya ingat. Saya pernah menggunakan metode ini untuk mengurutkan daftar angka."

"Bagus. Tapi metode ini jauh lebih kuat daripada yang terlihat pada pandangan pertama. Metode ini tidak hanya dapat mengurutkan angka, tetapi juga objek apa pun, berdasarkan kriteria apa pun. Dua antarmuka membantu metode ini: Sebanding dan Komparator . "

"Terkadang Anda perlu mengurutkan objek, bukan angka. Misalnya, anggaplah Anda memiliki daftar orang, dan Anda ingin mengurutkannya berdasarkan usia. Kami memiliki antarmuka Sebanding untuk ini."

"Pertama-tama izinkan saya menunjukkan kepada Anda sebuah contoh, dan kemudian semuanya akan menjadi lebih jelas:"

public class Woman implements Comparable<Woman>
{
public int age;

public Woman(int age) {
this.age = age;
}

public int compareTo(Woman o)
{
return this.age - o.age;
}
}

public static void main(String[] args )
{
ArrayList<Woman> women = new ArrayList<Woman>();
women.add(new Woman(18));
women.add(new Woman(21));
women.add(new Woman(5));

Collections.sort(women);
}

"Untuk mengurutkan objek, pertama-tama Anda harus tahu cara membandingkannya. Untuk ini, kami menggunakan Sebanding. Antarmuka Sebanding adalah generik, yang berarti ia menerima argumen tipe. Hanya ada satu metode generik: bandingkanTo(T o). Metode ini membandingkan objek saat ini (ini) dan objek yang diteruskan sebagai argumen (o) Dengan kata lain, kita perlu mengimplementasikan metode ini di kelas kita dan kemudian menggunakannya untuk membandingkan objek saat ini (ini) dengan objek yang diteruskan. "

"Dan bagaimana cara kerja compareTo? Saya berharap ini akan mengembalikan true atau false tergantung pada apakah objek yang diteruskan lebih besar atau lebih kecil."

"Semuanya lebih rumit di sini. Metode compareTo tidak mengembalikan true/false. Sebaliknya, ia mengembalikan int. Ini sebenarnya dilakukan untuk kesederhanaan.

"Ketika komputer perlu menentukan apakah satu angka lebih besar dari yang lain, itu hanya mengurangi angka kedua dari angka pertama dan kemudian melihat hasilnya. Jika hasilnya 0, maka angkanya sama. Jika hasilnya kurang dari nol , maka angka kedua lebih besar. Dan jika hasilnya lebih besar dari nol, maka angka pertama lebih besar."

"Logika yang sama berlaku di sini. Menurut spesifikasi, metode bandingkanTo harus mengembalikan nol jika objek yang dibandingkan sama. Jika metode bandingkanTo mengembalikan angka yang lebih besar dari nol, maka objek kita lebih besar dari objek yang diteruskan. "Jika bandingkanTo metode mengembalikan angka kurang dari nol, maka 'ini' kurang dari objek yang diteruskan."

"Itu sedikit aneh."

"Ya, tetapi jika Anda membandingkan objek hanya berdasarkan beberapa properti numerik, maka Anda dapat mengembalikan perbedaan di antara mereka dengan mengurangkan satu dari yang lain. Seperti yang dilakukan pada contoh di atas."

public int compareTo(Woman o)
{
return this.age - o.age;
}

"Kurasa aku mengerti segalanya. Tapi mungkin tidak. Tapi hampir semuanya."

"Bagus. Sekarang mari kita pertimbangkan masalah yang lebih praktis. Misalkan Anda telah menulis situs web keren untuk membuat pakaian wanita di China. Anda menggunakan kelas Wanita untuk mendeskripsikan pelanggan Anda. Anda bahkan membuat halaman web dengan tabel tempat Anda dapat melihat semuanya . Tapi ada masalah…”

"Objek Wanita Anda tidak hanya berisi usia, tetapi juga banyak data lain: nama depan, nama belakang, tinggi badan, berat badan, jumlah anak, dll."

"Tabel pengguna memiliki banyak kolom, dan inilah pertanyaannya: bagaimana Anda mengurutkan pengguna Anda dengan berbagai kriteria? Berdasarkan berat, usia, nama belakang?"

"Hmm. Ya, saya sering melihat tabel yang memungkinkan Anda mengurutkan berdasarkan kolom. Jadi, bagaimana Anda melakukannya?"

"Untuk ini, kami memiliki antarmuka kedua yang ingin saya ceritakan hari ini: antarmuka Komparator. Ini juga memiliki metode perbandingan, tetapi dibutuhkan dua argumen, bukan satu: int bandingkan(T o1, T o2). Begini caranya bekerja:"

public class Woman
{
public int age;
public int childrenCount;
public int weight;
public int height;
public String name;

public Woman(int age) {
this.age = age;
}
}

public static void main(String[] args )
{
ArrayList<Woman> women = new ArrayList<Woman>();
women.add(new Woman(18));
women.add(new Woman(21));
women.add(new Woman(5));

Comparator<Woman> compareByHeight = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.height - o2.height;
}
};

Collections.sort(women, compareByHeight);
}

"Antarmuka Komparator tidak menyembunyikan logika perbandingan objek di dalam kelas objek yang dibandingkan. Sebaliknya, ini diimplementasikan dalam kelas terpisah."

"Jadi, saya dapat membuat beberapa kelas yang mengimplementasikan antarmuka Comparator, dan membuat masing-masing kelas membandingkan properti yang berbeda? Berat dalam satu kelas, usia di kelas lain, dan tinggi di sepertiga?"

"Ya, ini sangat sederhana dan nyaman."

"Kami hanya memanggil metode Collections.sort , meneruskan daftar objek dan objek khusus lainnya sebagai argumen kedua, yang mengimplementasikan antarmuka Comparator dan memberi tahu Anda cara membandingkan pasangan objek dengan benar dalam proses penyortiran."

"Hmm. Saya pikir saya mengerti segalanya. Biarkan saya mencobanya. Katakanlah saya perlu mengurutkan pengguna berdasarkan berat. Ini akan menjadi seperti ini:"

Comparator<Woman> compareByWeight = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.weight - o2.weight;
}
};

Collections.sort(women, compareByWeight);

"Iya benar sekali."

"Bagus. Tapi bagaimana jika saya ingin menyortir dalam urutan terbalik?"

"Pikirkan. Jawabannya sangat sederhana!"

"Aku mengerti! Seperti ini:"

return o1.weight - o2.weight;

return o2.weight – o1.weight;

"Benar. Kerja bagus."

"Dan jika saya ingin mengurutkan berdasarkan nama belakang? Bagaimana cara mengurutkan string, Bilaabo?"

"Kelas String sudah mengimplementasikan metode compareTo. Anda hanya perlu memanggilnya:"

Comparator<Woman> compareByName = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.name.compareTo(o2.name);
}
};

Collections.sort(women, compareByName);

"Itu pelajaran yang bagus, Bilaabo. Terima kasih banyak."

"Dan terima kasih untukmu, temanku!"