Java: What is the difference between Comparable and Comparator in Java?

Comparable — natural ordering defined inside the class itself. Comparator — custom external ordering defined outside the class.

Think of it like a library: Comparable is like the library's own alphabetical sorting system built into the catalog. Comparator is like a librarian who can sort books by any criteria you choose — color, size, publication date, or popularity.

Comparable (java.lang.Comparable):

• Defines natural ordering for a class (the "default" sort).
• The class itself implements Comparable<T>.
• Uses the compareTo(T o) method — returns negative, zero, or positive.
• There can be only one natural ordering per class.
• Modifies the original class.

1public class Person implements Comparable<Person> {
2    private String name;
3    private int age;
4
5    public Person(String name, int age) {
6        this.name = name;
7        this.age = age;
8    }
9
10    @Override
11    public int compareTo(Person other) {
12        // Natural order: by name alphabetically
13        int nameComparison = this.name.compareTo(other.name);
14        if (nameComparison != 0) {
15            return nameComparison;
16        }
17        // Tie-breaker: by age ascending
18        return Integer.compare(this.age, other.age);
19    }
20
21    @Override
22    public String toString() {
23        return name + " (age " + age + ")";
24    }
25}
26
27// Usage:
28List<Person> people = new ArrayList<>();
29people.add(new Person("Charlie", 30));
30people.add(new Person("Alice", 25));
31people.add(new Person("Bob", 35));
32Collections.sort(people); // Uses compareTo
33// Output: Alice (25), Bob (35), Charlie (30)

Comparator (java.util.Comparator):

• Defines custom/external ordering — separate from the class.
• You create a new Comparator object per sort criteria.
• Uses the compare(T o1, T o2) method.
• You can have multiple Comparators for the same class.
• Does NOT modify the original class at all.

1public class Person {
2    private String name;
3    private int age;
4
5    public Person(String name, int age) {
6        this.name = name;
7        this.age = age;
8    }
9
10    // Getters
11    public String getName() { return name; }
12    public int getAge() { return age; }
13}
14
15// Comparator by age
16Comparator<Person> byAge = (p1, p2) -> Integer.compare(p1.getAge(), p2.getAge());
17
18// Comparator by name length
19Comparator<Person> byNameLength =
20    (p1, p2) -> Integer.compare(p1.getName().length(), p2.getName().length());
21
22// Using them:
23people.sort(byAge);           // Sort by age
24people.sort(byNameLength);    // Sort by name length
25people.sort(byAge.reversed()); // Reverse age order
26
27// Chaining with Comparator.comparing:
28people.sort(
29    Comparator.comparing(Person::getAge)
30              .thenComparing(Person::getName)
31);

Key differences:

• Comparable — natural order, one per class, modifies the class.
• Comparator — custom order, multiple per class, external.
• Comparable — compareTo() on this vs other.
• Comparator — compare() takes two separate parameters.
• Comparable — used by Collections.sort(list) with one arg.
• Comparator — used by Collections.sort(list, comparator) with two args.

When to use which:

• Use Comparable when there is one obvious, universal sort order.
• Use Comparator when you need multiple sort orders or can't modify the class (e.g., third-party library classes).

Common mistake:

• Forgetting that compareTo must be consistent with equals. If compareTo returns 0 but equals returns false, collections like TreeSet will behave incorrectly — they might not detect duplicates properly.

Java 8+ Tip: The Comparator interface now has default methods like thenComparing(), reversed(), nullsFirst(), and nullsLast() that make chaining comparators extremely clean.