Mindkettő meghatározza, hogyan rendezzük az objektumokat, de másként: Comparable egy osztály természetes rendezéseit határozza meg (az osztály maga valósítja meg), míg a Comparator egy , alternatív rendezést határozza meg (egy külön objektum). A választás attól függ, hogy a rendezés veleszületett vagy helyzettől függő.
public 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)
A Comparable az osztályban él a compareTo() segítségével, annak egyetlen, alapértelmezett rendezéseit definiálva. A Collections.sort, TreeSet, TreeMap stb. automatikusan használják.
// 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
A Comparator egy külön objektum, amely lehetővé teszi több eltérő rendezés meghatározását ugyanahhoz az osztályhoz anélkül, hogy módosítanánk azt.
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);
A builder stílusú comparing/thenComparing módszerek az összetett több mezős rendezéseket tömörvé és olvashatóvá teszik.
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)
Az objektumok rendezése állandó szükséglet — listák rendezése, TreeSet/TreeMap használata, min/max keresése.
A Comparable-vs-Comparator közötti különbség megértése lehetővé teszi a helyes választást: Comparable egy osztály egyetlen veleszületett rendezéséhez (beépítve, alapértelmezettként használva), Comparator több vagy külső rendezések rugalmasságához (azonos adatok különböző mezők szerinti rendezése, vagy olyan típusok rendezése, amelyeket nem kontrollálunk).
A modern folyadék Comparator API (comparing/thenComparing/reversed) elegánsá teszi a többszintű rendezést.
Mindkettőben való jártasság — és hogy mikor alkalmazható mindegyik — nélkülözhetetlen a rendezett adatstruktúrákkal való munka során, és Java-ban gyakori gyakorlati és interjú témakör.