Ambos definem como ordenar objetos, mas de maneiras diferentes: Comparable define uma ordenação natural de uma classe (implementada pela própria classe), enquanto Comparator define uma ordenação , alternativa (um objeto separado). A escolha depende de se a ordenação é intrínseca ou 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 fica dentro da classe via compareTo(), definindo sua única ordenação padrão. É usado automaticamente 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 é um objeto separado, permitindo definir múltiplas ordenações diferentes para a mesma classe sem modificá-la.
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);
Os métodos em estilo construtor comparing/thenComparing tornam a classificação complexa de múltiplos campos concisa e legível.
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 é uma necessidade constante — classificar listas, usar TreeSet/TreeMap, encontrar min/máx.
Entender a distinção Comparable versus Comparator permite escolher corretamente: Comparable para uma única ordenação intrínseca de uma classe (incorporada, usada por padrão), Comparator para a flexibilidade de múltiplas ou ordenações externas (classificar os mesmos dados por diferentes campos, ou ordenar tipos que você não controla).
A API Comparator fluente moderna (comparing/thenComparing/reversed) torna a classificação em vários níveis elegante.
Dominar ambos — e quando cada um se encaixa — é essencial para trabalhar com estruturas de dados ordenadas e é um tópico prático e de entrevista frequente em Java.