Ambii definesc cum să ordonezi obiecte, dar în moduri diferite: Comparable definește o ordonare naturală a unei clase (implementată de clasa în sine), în timp ce Comparator definește o ordonare , alternativă (un obiect separat). Alegerea depinde de dacă ordonarea este intrinsecă sau situațională.
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 se află înăuntrul clasei prin compareTo(), definind ordinea sa unică, implicită. Este folosit automat de Collections.sort, TreeSet, TreeMap, ș.a.m.d.
// 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 este un obiect separat, permițând să definești mai multe ordonări diferite pentru aceeași clasă fără a o modifica.
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);
Metodele în stil builder comparing/thenComparing fac sortarea complexă pe mai multe câmpuri concisă și lizibilă.
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)
Ordonarea obiectelor este o nevoie constantă — sortarea listelor, utilizarea TreeSet/TreeMap, găsirea min/max.
Înțelegerea distincției Comparable-vs-Comparator te lasă să alegi corect: Comparable pentru ordinea intrinsecă unică a unei clase (încorporată, folosită în mod implicit), Comparator pentru flexibilitatea ordonărilor multiple sau externe (sortează aceleași date după câmpuri diferite, sau ordonează tipuri pe care nu le controlezi).
API-ul Comparator fluent modern (comparing/thenComparing/reversed) face sortarea pe mai multe niveluri elegantă.
Stăpânirea ambelor — și când fiecare se potrivește — este esențială pentru a lucra cu structuri de date sortate și este un subiect practic și de interviu frecvent în Java.