Java - Bagaimana untuk Menggunakan Comparator?

Hai sana, para ahli Java masa depan! ? Hari ini, kita akan memulai perjalanan yang menarik ke dunia Java Comparators. Jangan khawatir jika Anda baru belajar programming – saya akan menjadi panduan yang ramah, dan kita akan mengambil langkah ini secara bertahap. Pada akhir panduan ini, Anda akan dapat mengurutkan objek seperti seorang pro!

Apa Itu Comparator?

Sebelum kita mendalam, mari kita khayal Anda sedang mengatur rak buku Anda. Anda mungkin ingin mengatur buku Anda berdasarkan judul, penulis, atau tanggal terbit. Dalam Java, Comparator adalah seperti petugas perpustakaan pribadi Anda yang tahu bagaimana mengurutkan koleksi Anda berdasarkan kriteria apa pun yang Anda pilih.

Dalam istilah teknis, Comparator adalah sebuah interface di Java yang memungkinkan kita untuk menentukan urutan khusus untuk objek. Ini sangat berguna saat kita ingin mengurutkan objek yang tidak memiliki urutan alami, atau saat kita ingin mengurutkan mereka dalam cara yang berbeda dari urutan alami mereka.

Interface Comparator

Mari kita periksa interface Comparator lebih detil:

public interface Comparator<T> {
int compare(T o1, T o2);
}

Jangan ter intimidasi! Itu lebih mudah daripada yang Anda pikirkan. <T> hanya mengatakan bahwa interface ini dapat bekerja dengan jenis objek apa pun. Metode compare adalah tempat di mana magik terjadi – itu seperti meminta petugas perpustakaan Anda untuk membandingkan dua buku.

Bagaimana Metode compare Bekerja

Metode compare menerima dua objek dan mengembalikan sebuah integer:

• Jika objek pertama dianggap "lebih kecil" daripada yang kedua, itu mengembalikan angka negatif.
• Jika mereka dianggap "-sama," itu mengembalikan nol.
• Jika yang pertama "lebih besar," itu mengembalikan angka positif.

Pertimbangkan ini seperti sebuah skala keseimbangan. Jika objek pertama lebih ringan, skala condong ke sisi negatif. Jika mereka sama, skala tetap keseimbangan di nol. Jika yang pertama lebih berat, skala condong ke sisi positif.

Membuat Comparator Pertama Anda

Mari kita membuat Comparator sederhana untuk mengurutkan string berdasarkan panjangnya. Kita akan menamanya StringLengthComparator:

import java.util.Comparator;

public class StringLengthComparator implements Comparator<String> {
@Override
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
}

Ini adalah apa yang terjadi:

1. Kita mengimpor interface Comparator dari java.util.
2. Kita membuat kelas yang mengimplementasi Comparator<String>, berarti itu akan membandingkan objek String.
3. Kita menimpa metode compare untuk mengurangkan panjang string kedua dari yang pertama.

Menggunakan Comparator Anda

Sekarang kita memiliki Comparator, mari kita gunakan itu! Kita akan membuat daftar string dan mengurutkannya:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ComparatorExample {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Pear");
fruits.add("Banana");
fruits.add("Kiwi");

System.out.println("Sebelum pengurutan: " + fruits);

Collections.sort(fruits, new StringLengthComparator());

System.out.println("Setelah pengurutan: " + fruits);
}
}

Output:

Sebelum pengurutan: [Apple, Pear, Banana, Kiwi]
Setelah pengurutan: [Pear, Kiwi, Apple, Banana]

mari kitauraikan ini:

1. Kita membuat daftar nama buah.
2. Kita mencetak daftar asli.
3. Kita menggunakan Collections.sort() dengan Comparator khusus untuk mengurutkan daftar.
4. Kita mencetak daftar yang diurutkan.

Perhatikan bagaimana buah-buahan sekarang diurutkan berdasarkan panjang nama mereka!

Ekspresi Lambda: Jalan Pintas

Java 8 memperkenalkan ekspresi lambda, yang dapat membuat Comparator Anda lebih ringkas. Ini adalah contoh yang sama menggunakan lambda:

Collections.sort(fruits, (s1, s2) -> s1.length() - s2.length());

Baris ini melakukan hal yang sama seperti kelas StringLengthComparator! Itu seperti mengatakan ke Java, "Hey, saat Anda membandingkan dua string, hanya kurangkan panjangnya."

Mengurutkan Objek Khusus

Sekarang, mari kita naik tingkat dan mengurutkan beberapa objek khusus. Bayangkan kita memiliki kelas Person:

public class Person {
private String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

// Getter dan Setter...

@Override
public String toString() {
return name + " (" + age + ")";
}
}

Kita dapat membuat Comparator untuk mengurutkan objek Person berdasarkan umur:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class PersonSortExample {
public static void main(String[] args) {
List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 25));
people.add(new Person("Bob", 30));
people.add(new Person("Charlie", 22));

System.out.println("Sebelum pengurutan: " + people);

Collections.sort(people, Comparator.comparingInt(Person::getAge));

System.out.println("Setelah pengurutan: " + people);
}
}

Output:

Sebelum pengurutan: [Alice (25), Bob (30), Charlie (22)]
Setelah pengurutan: [Charlie (22), Alice (25), Bob (30)]

Di sini, kita menggunakan Comparator.comparingInt(), yang membuat Comparator berdasarkan nilai integer – dalam hal ini, umur. Person::getAge adalah referensi metode, mengatakan ke Java untuk menggunakan metode getAge() untuk mendapatkan nilai yang akan dibandingkan.

Membalik Urutan

Apa bila kita ingin mengurutkan secara descending? Mudah-mudahan! Gunakan metode reversed():

Collections.sort(people, Comparator.comparingInt(Person::getAge).reversed());

Ini akan mengurutkan objek Person dari yang tertua ke yang termuda.

Menggabungkan Comparators

kadang-kadang, kita mungkin ingin mengurutkan berdasarkan beberapa kriteria. Misalnya, mari kita urutkan Person berdasarkan umur, dan jika umur sama, berdasarkan nama:

Comparator<Person> ageAndNameComparator = Comparator
.comparingInt(Person::getAge)
.thenComparing(Person::getName);

Collections.sort(people, ageAndNameComparator);

Ini membuat Comparator yang pertama kali membandingkan umur, dan jika mereka sama, membandingkan nama.

Kesimpulan

Selamat! Anda baru saja belajar tentang Java Comparators. Dari mengurutkan string sederhana hingga objek kompleks, Anda sekarang memiliki kekuatan untuk mengatur data dalam cara apa pun yang Anda pilih. Ingat, latihan membuat ahli, jadi jangan khawatir untuk mencoba kriteria pengurutan berbeda dan objek.

Sekarang Anda terus melanjutkan perjalanan Java Anda, Anda akan menemukan Comparators menjadi alat yang tak ternilai di dalam perangkat pengembangan Anda. Mereka tidak hanya untuk mengurutkan daftar – mereka digunakan dalam banyak koleksi dan algoritma Java untuk menjaga urutan dan melakukan pencarian efisien.

Terus coding, terus belajar, dan yang paling penting, bersenang-senang! Siapa tahu? Mungkin suatu hari Anda akan menulis algoritma pengurutan yang merevolusi cara kita mengatur data. Sampai saat itu, selamat berbanding! ??‍??‍?

Metode-Metode Interface Comparator

Berikut adalah tabel metode kunci di interface Comparator:

Metode	Deskripsi
compare(T o1, T o2)	Membandingkan dua argumen untuk urutan.
equals(Object obj)	Menunjukkan apakah objek lain "sama" dengan comparator ini.
reversed()	Mengembalikan comparator yang menimpa urutan ini.
thenComparing(Comparator<? super T> other)	Mengembalikan comparator leksikografik dengan comparator lain.
thenComparingInt(ToIntFunction<? super T> keyExtractor)	Mengembalikan comparator leksikografik dengan fungsi yang mengekstrak kunci pengurutan integer.
thenComparingLong(ToLongFunction<? super T> keyExtractor)	Mengembalikan comparator leksikografik dengan fungsi yang mengekstrak kunci pengurutan long.
thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)	Mengembalikan comparator leksikografik dengan fungsi yang mengekstrak kunci pengurutan double.

Metode ini menyediakan alat kuat untuk membuat logika pengurutan kompleks, memungkinkan Anda untuk membuat comparator bagi jenis data apa pun dan kriteria pengurutan apa pun.

Credits: Image by storyset