Les deux définissent comment ordonner les objets, mais différemment : Comparable définit l'ordre naturel d'une classe (implémenté par la classe elle-même), tandis que Comparator définit un ordre et alternatif (un objet séparé). Le choix dépend de si l'ordre est intrinsèque ou situationnel.
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 vit à l'intérieur de la classe via compareTo(), définissant son unique ordre par défaut. Il est utilisé automatiquement par 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 est un objet séparé, vous permettant de définir plusieurs ordres différents pour la même classe sans la modifier.
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);
Les méthodes comparing/thenComparing de style builder rendent le tri multi-champs complexe concis et lisible.
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)
Ordonner les objets est un besoin constant — trier des listes, utiliser TreeSet/TreeMap, trouver le minimum/maximum.
Comprendre la distinction Comparable-vs-Comparator vous permet de choisir correctement : Comparable pour l'unique ordre intrinsèque d'une classe (intégré, utilisé par défaut), Comparator pour la flexibilité de plusieurs ordres ou ordres externes (trier les mêmes données par différents champs, ou ordonner des types que vous ne contrôlez pas).
L'API Comparator fluide moderne (comparing/thenComparing/reversed) rend le tri multi-niveaux élégant.
Maîtriser les deux — et quand chacun convient — est essentiel pour travailler avec des structures de données triées et est un sujet fréquent pratique et d'entrevue en Java.