Beide definiëren hoe objecten geordend worden, maar op verschillende manieren: Comparable definieert een klasse's natuurlijke ordening (geïmplementeerd door de klasse zelf), terwijl Comparator een , alternatieve ordening definieert (een apart object). De keuze hangt af van of de ordening intrinsiek of situationeel is.
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 bevindt zich binnen de klasse via compareTo(), en definieert de enige, standaardordening. Het wordt automatisch gebruikt door Collections.sort, TreeSet, TreeMap, enzovoort.
// 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 is een apart object, waarmee je meerdere verschillende ordeningen voor dezelfde klasse kunt definiëren zonder deze aan te passen.
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);
De builder-style comparing/thenComparing methoden maken sorteren op complexe multi-veld niveau's beknopt en leesbaar.
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)
Objecten ordenen is een voortdurende behoefte — lijsten sorteren, TreeSet/TreeMap gebruiken, min/max zoeken.
De Comparable-vs-Comparator onderscheiding begrijpen stelt je in staat om correct te kiezen: Comparable voor een klasse's enige intrinsieke ordening (ingebouwd, standaard gebruikt), Comparator voor de flexibiliteit van meerdere of externe ordeningen (dezelfde gegevens op verschillende velden sorteren, of typen ordenen die je niet beheert).
De moderne fluent Comparator API (comparing/thenComparing/reversed) maakt sorteren op meerdere niveaus elegant.
Beiden onder de knie hebben — en wanneer elk past — is essentieel voor het werken met gesorteerde datastructuren en is een frequent praktisch en interviewonderwerp in Java.