Ambos definen cómo ordenar objetos, pero de manera diferente: Comparable define una clasificación natural de una clase (implementada por la propia clase), mientras que Comparator define una clasificación alternativa (un objeto separado). La elección depende de si la clasificación es intrínseca o situacional.
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 vive dentro de la clase a través de compareTo(), definiendo su única clasificación predeterminada. Se utiliza automáticamente por 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 es un objeto separado, que te permite definir múltiples clasificaciones diferentes para la misma clase sin 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);
Los métodos comparing/thenComparing de estilo constructor hacen que la clasificación compleja de múltiples campos sea concisa y legible.
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)
Ordenar objetos es una necesidad constante — ordenar listas, usar TreeSet/TreeMap, encontrar min/max.
Comprender la distinción Comparable-vs-Comparator te permite elegir correctamente: Comparable para la única clasificación intrínseca de una clase (incorporada, se usa por defecto), Comparator para la flexibilidad de múltiples clasificaciones o externas (ordena los mismos datos por diferentes campos, u ordena tipos que no controlas).
La API moderna y fluida de Comparator (comparing/thenComparing/reversed) hace que la clasificación de múltiples niveles sea elegante.
Dominar ambos — y cuándo encaja cada uno — es esencial para trabajar con estructuras de datos ordenadas y es un tema práctico y de entrevista frecuente en Java.