Entrambi definiscono come ordinare oggetti, ma in modo diverso: Comparable definisce l'ordinamento naturale di una classe (implementato dalla classe stessa), mentre Comparator definisce un ordinamento e alternativo (un oggetto separato). La scelta dipende dal fatto che l'ordinamento sia intrinseco o situazionale.
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 si trova dentro la classe tramite compareTo(), definendo il suo unico ordinamento predefinito. Viene utilizzato automaticamente da Collections.sort, TreeSet, TreeMap, ecc.
// 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 è un oggetto separato che ti permette di definire più ordinamenti diversi per la stessa classe senza modificarla.
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);
I metodi di stile builder comparing/thenComparing rendono l'ordinamento multi-campo complesso conciso e leggibile.
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)
Ordinare oggetti è un'esigenza costante — ordinare liste, utilizzare TreeSet/TreeMap, trovare min/max.
Comprendere la distinzione Comparable-vs-Comparator ti permette di scegliere correttamente: Comparable per l'unico ordinamento intrinseco di una classe (integrato, utilizzato per impostazione predefinita), Comparator per la flessibilità di più ordinamenti o ordinamenti esterni (ordinare gli stessi dati per campi diversi, o ordinare tipi che non controlli).
L'API Comparator fluente moderna (comparing/thenComparing/reversed) rende l'ordinamento multi-livello elegante.
Padroneggiare entrambi — e quando ognuno è appropriato — è essenziale per lavorare con strutture dati ordinate ed è un argomento pratico e di intervista frequente in Java.