Kedua-duanya mendefinisikan bagaimana menentukan susunan objek, tetapi dengan cara yang berbeza: Comparable mendefinisikan susunan semula jadi kelas (dilaksanakan oleh kelas itu sendiri), manakala mendefinisikan susunan , alternatif (objek berasingan). Pilihan bergantung pada sama ada susunan itu bersifat intrinsik atau situasi.
Comparatorpublic class Person implements Comparable<Person> {
private String name;
private int age;
@Override
public int compareTo(Person other) { // defines THE natural order
return Integer.compare(this.age, other.age); // by age
}
// return: negative if this < other, 0 if equal, positive if this > other
}
List<Person> people = ...;
Collections.sort(people); // uses compareTo — sorts by age (the natural order)
Comparable hidup di dalam kelas melalui compareTo(), mendefinisikan susunnya satu-satunya, lalai. Ia digunakan secara automatik oleh Collections.sort, TreeSet, TreeMap, dan lain-lain.
// define orderings OUTSIDE the class — as many as you need
Comparator<Person> byName = (a, b) -> a.getName().compareTo(b.getName());
Comparator<Person> byAge = Comparator.comparingInt(Person::getAge);
people.sort(byName); // sort by name
people.sort(byAge.reversed()); // by age, descending
Comparator ialah objek berasingan, membenarkan anda mentakrifkan pelbagai susunan berbeza untuk kelas yang sama tanpa mengubahnya.
Comparator<Person> comp = Comparator
.comparing(Person::getLastName) // primary: last name
.thenComparing(Person::getFirstName) // tie-break: first name
.thenComparingInt(Person::getAge) // then: age
.reversed(); // reverse the whole thing
people.sort(comp);
Kaedah gaya pembina comparing/thenComparing membuat penyusunan pelbagai medan yang kompleks ringkas dan mudah dibaca.
Comparable → the class has ONE obvious natural order (numbers by value, strings
alphabetically, dates chronologically); you own the class
Comparator → you need MULTIPLE orderings, situational/custom ordering, OR you
can't modify the class (e.g. sorting a third-party type differently)
Menentu susunan objek adalah keperluan yang berterusan — menyusun senarai, menggunakan TreeSet/TreeMap, mencari min/max.
Memahami perbezaan Comparable-lawan-Comparator membenarkan anda memilih dengan betul: Comparable untuk susunan intrinsik tunggal kelas (tersusun dalam, digunakan secara lalai), Comparator untuk kefleksibelan banyak atau susunan luaran (menyusun data yang sama mengikut medan berbeza, atau menentukan susunan jenis yang anda tidak kawal).
API Comparator lancar moden (comparing/thenComparing/reversed) membuat penyusunan pelbagai peringkat elegan.
Menguasai kedua-duanya — dan mengetahui bila setiap satu sesuai — adalah penting untuk bekerja dengan struktur data tersusun dan merupakan topik praktikal dan temu duga yang kerap dalam Java.