Båda definierar hur man ordnar objekt, men på olika sätt: Comparable definierar en klass naturliga ordning (implementerad av själva klassen), medan Comparator definierar en , alternativ ordning (ett separat objekt). Valet beror på om ordningen är inneboende eller situationsberoende.
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 finns inuti klassen via compareTo(), som definierar dess enda, standardordning. Den används automatiskt av Collections.sort, TreeSet, TreeMap, etc.
// 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 är ett separat objekt som låter dig definiera flera olika ordningar för samma klass utan att ändra 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);
Metoderna i byggarstil comparing/thenComparing gör komplex sortering av flera fält koncis och 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)
Att ordna objekt är ett konstant behov — sortering av listor, användning av TreeSet/TreeMap, söka min/max.
Att förstå distinktionen Comparable-vs-Comparator låter dig välja rätt: Comparable för en klasses enda inneboende ordning (inbyggd, använd som standard), Comparator för flexibiliteten hos flera eller externa ordningar (sortera samma data efter olika fält, eller ordna typer du inte kontrollerar).
Det moderna flytande Comparator API:et (comparing/thenComparing/reversed) gör sortering på flera nivåer elegant.
Att behärska båda — och när var och en passar — är väsentligt för att arbeta med sorterade datastrukturer och är ett ofta återkommande praktisk och intervjuämne i Java.