Begge definerer hvordan objekter ordnes, men på forskjellige måter: Comparable definerer en klasses naturlige ordning (implementert av klassen selv), mens Comparator definerer en , alternativ ordning (et eget objekt). Valget avhenger av om ordningen er iboende eller situasjonsbetinget.
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 ligger inne i klassen via compareTo(), og definerer dens eneste, standardordning. Det brukes automatisk av 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 eget objekt, som lar deg definere flere forskjellige ordninger for den samme klassen uten å endre 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 metoder gjør kompleks sortering på flere felt konsise og lesbare.
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)
Å ordne objekter er et konstant behov — sortere lister, bruke TreeSet/TreeMap, finne min/maks.
Å forstå Comparable-vs-Comparator skilnaden lar deg velge riktig: Comparable for en klasses eneste iboende ordning (bygget inn, brukt som standard), Comparator for fleksibiliteten med flere eller eksterne ordninger (sorter samme data på forskjellige felt, eller ordne typer du ikke kontrollerer).
Det moderne flytende Comparator API (comparing/thenComparing/reversed) gjør sortering på flere nivåer elegant.
Å mestre begge — og når hver passer — er vesentlig for å arbeide med sorterte datastrukturer og er et hyppig praktisk og intervju-emne i Java.