Comparable.compareTo vs Comparator.compare: natural ordering vs external strategy

• Comparable – implemented BY the class; defines the natural ordering via compareTo(T other). One per class.
• Comparator – implemented OUTSIDE the class; defines an external sorting strategy via compare(T a, T b). Unlimited per class.
• naturalOrder() – returns a Comparator that delegates to the element's compareTo method, bridging Comparable to Comparator.
• reverseOrder() – returns a Comparator that is the reverse of the natural ordering.
• Strategy Pattern – Comparator is an interchangeable sorting strategy; different screens can use different Comparators for the same data.

What is the difference between Comparable and Comparator?

What is Comparable?

Comparable is implemented by the class that wants a default sort order. The class implements Comparable and overrides compareTo(T other).

package com.bank.model;

import java.math.BigDecimal;

public class Trade implements Comparable<Trade> {
    private String tradeId;
    private BigDecimal amount;

    @Override
    public int compareTo(Trade other) {
        return this.tradeId.compareTo(other.tradeId);  // natural order = by tradeId
    }
}

// Natural order used by:
Collections.sort(trades);                    // uses compareTo
trades.stream().sorted().toList();           // uses compareTo
new TreeSet<>(trades);                       // natural order

What is Comparator?

Comparator is defined outside the class. No modification to Trade is needed.

// External Comparators:
Comparator<Trade> byAmount = Comparator.comparing(Trade::getAmount);
Comparator<Trade> byAmountDesc = Comparator.comparing(Trade::getAmount).reversed();
Comparator<Trade> bySymbolThenAmount = Comparator.comparing(Trade::getSymbol)
    .thenComparing(Trade::getAmount);

// Usage:
trades.sort(byAmount);
trades.stream().sorted(byAmountDesc).toList();
new TreeSet<>(bySymbolThenAmount);

How do naturalOrder and reverseOrder bridge the two?

// naturalOrder: wraps Comparable.compareTo as a Comparator
Comparator<String> natural = Comparator.naturalOrder();
// Equivalent to: (a, b) -> a.compareTo(b)

// Used in nullsLast (which requires a Comparator argument)
Comparator<Trade> deptSort = Comparator.comparing(Trade::getDepartment,
    Comparator.nullsLast(Comparator.naturalOrder()));

// reverseOrder: reverse of natural ordering
Comparator<String> reversed = Comparator.reverseOrder();
trades.stream()
    .sorted(Comparator.comparing(Trade::getAmount, Comparator.reverseOrder()))
    .toList();

When do you use Comparable vs Comparator?

| Aspect | Comparable | Comparator |
|---|---|---|
| Defined | Inside the class | Outside the class |
| How many | One per class | Unlimited per class |
| Interface | compareTo(T other) | compare(T a, T b) |
| Modification | Requires changing the class | No class change needed |
| Default for | sorted(), TreeSet, TreeMap | Passed as parameter |
| Example | String alphabetical order | Sort strings by length |

What are common mistakes?

// WRONG: trying to sort a class that does not implement Comparable
class Account { String id; BigDecimal balance; }
List<Account> accounts = List.of(new Account(), new Account());
Collections.sort(accounts);  // ClassCastException: Account cannot be cast to Comparable

// CORRECT: provide a Comparator
accounts.sort(Comparator.comparing(Account::getBalance));

What should a senior engineer know?

• Comparable should be consistent with equals: if a.compareTo(b) == 0, then a.equals(b) should be true. TreeSet uses compareTo for uniqueness, not equals.
• Comparator.comparing is the modern way to create comparators; avoid writing compare() by hand.
• The Comparator fluent API (comparing, thenComparing, reversed) follows the Strategy Pattern.

What are common interview follow-up questions?

• Can a class implement Comparable and still be sorted with a Comparator? (Yes. The Comparator overrides the natural order.)
• What happens if compareTo is inconsistent with equals? (TreeSet may behave differently from HashSet for the same elements.)
• Is Comparable required for TreeSet? (Either the elements must be Comparable, or you must provide a Comparator to the TreeSet constructor.)