Begge definerer, hvordan sortere objekter, men på forskellige måder: Comparable definerer en klasses naturlige sortering (implementeret af klassen selv), mens Comparator definerer en alternativ sortering (et separat objekt). Valget afhænger af, om sorteringen er indre eller situationsbetinget.
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)
Comparable bor inde i klassen via compareTo(), og definerer dens eneste standard-sortering. Det bruges automatisk af Collections.sort, TreeSet, TreeMap osv.
// 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 er et separat objekt, der lader dig definere flere forskellige sorteringer for samme klasse uden at ændre den.
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);
Builder-stil comparing/thenComparing metoderne gør kompleks multi-felt sortering kortfattet og læsbar.
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)
Sortering af objekter er et konstant behov — sortering af lister, brug af TreeSet/TreeMap, find min/max.
Forståelse af Comparable-vs-Comparator skel lader dig vælge korrekt: Comparable til en klasses eneste iboende sortering (indbygget, brugt som standard), Comparator til fleksibilitet med flere eller eksterne sorteringer (sorter de samme data efter forskellige felter, eller sorter typer du ikke kontrollerer).
Det moderne flydende Comparator API (comparing/thenComparing/reversed) gør multi-niveau sortering elegant.
At beherske begge — og hvornår hver passer — er væsentligt for at arbejde med sorterede datastrukturer og er et hyppigt praktisk og interview-emne i Java.