Both define how to order objects, but differently: Comparable defines a class's natural ordering (implemented by the class itself), while Comparator defines an , alternative ordering (a separate object). The choice depends on whether the ordering is intrinsic or situational.
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 lives inside the class via compareTo(), defining its single, default ordering. It's used automatically by 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 is a separate object, letting you define multiple different orderings for the same class without modifying it.
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);
The builder-style comparing/thenComparing methods make complex multi-field sorting concise and readable.
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)
Ordering objects is a constant need — sorting lists, using TreeSet/TreeMap, finding min/max.
Understanding the Comparable-vs-Comparator distinction lets you choose correctly: Comparable for a class's single intrinsic ordering (built in, used by default), Comparator for the flexibility of multiple or external orderings (sort the same data by different fields, or order types you don't control).
The modern fluent Comparator API (comparing/thenComparing/reversed) makes multi-level sorting elegant.
Mastering both — and when each fits — is essential for working with sorted data structures and is a frequent practical and interview topic in Java.