Comparable vs Comparator

Comparable and Comparator both define ordering, but they live in different places and serve different needs. Comparable is implemented inside the class itself and defines the type's natural ordering. Its method is compareTo, which takes a single argument — the other object — and returns a negative number if this object is smaller, zero if they're equal, or a positive number if it's larger. For example, String sorts alphabetically and Integer sorts numerically because they implement Comparable. The key limitation is that a type has exactly one natural order. Comparator is different: it's a separate object that defines ordering externally. Its method is compare, which takes two arguments and compares them. Because it lives outside the class, you can create as many comparators as you like — sort employees by name, by age, by salary — and you can even sort classes whose source code you don't own, which you can't do with Comparable. So the rule of thumb is: if there's one obvious default ordering and you own the class, make it Comparable. For anything situational — custom rules, multiple sort orders, descending order, or third-party types — pass a Comparator. A nice modern detail to mention is comparator chaining. You can write Comparator.comparing by one field, then thenComparing for a tiebreaker, and reversed to flip the direction, all in one readable expression. The classic mistakes are mixing up the method signatures — compareTo takes one argument, compare takes two — and thinking you can only sort with Comparable, when Comparator is actually the more flexible tool.