Comparators

Written Explanation

The Comparator interface

java.util.Comparator<T> has one abstract method, compare:

public interface Comparator<T> {
    int compare(T first, T second);
    // plus many default and static helper methods
}

It follows the same sign rules as compareTo: negative means first goes before second, zero means a tie, positive means first goes after. The difference is that the comparison lives in a separate object that takes both elements as arguments. The class being sorted needs no changes.

Writing one by hand

Using the interface skills from BEG-024, a comparator is just a class that implements the interface. For a Player with getName() and getScore():

import java.util.Comparator;

public class ByName implements Comparator<Player> {
    @Override
    public int compare(Player a, Player b) {
        return a.getName().compareTo(b.getName());
    }
}

Use it by passing an instance to sort:

players.sort(new ByName());

List.sort(Comparator) sorts the list in place. Passing null instead means "use the natural order". According to the Java documentation, this sort is stable: elements that compare as equal keep their original relative order.

Building comparators from a field

Writing a class per order is long. Comparator has static builders. Comparator.comparing takes a "key extractor", a method that pulls out the value to compare, and uses that key's natural order:

players.sort(Comparator.comparing(Player::getName));          // by name, A to Z
players.sort(Comparator.comparingInt(Player::getScore));      // by score, low to high

For a primitive int key use comparingInt (there are comparingLong and comparingDouble too): it avoids converting every value to an object, and it uses Integer.compare inside, so there is no subtraction trap. The key of comparing must itself be Comparable; String is.

Reversing

reversed() returns a comparator with the opposite order:

players.sort(Comparator.comparingInt(Player::getScore).reversed());   // high to low

Written by hand, "descending" means swapping the arguments: Integer.compare(b.getScore(), a.getScore()). Do not negate the result of compareTo, with a minus sign, to reverse it. For Integer.MIN_VALUE, negation overflows (it stays negative), so the swap or reversed() is the safe way.

Handy ready-made comparators

• Comparator.naturalOrder() and Comparator.reverseOrder(): the natural order of a Comparable type, and the opposite.
• String.CASE_INSENSITIVE_ORDER: compares strings ignoring case.
• Comparator.nullsFirst(c) and Comparator.nullsLast(c): wrap another comparator so that null elements do not crash it, placing them first or last.

Using a comparator with sorted collections

TreeSet and TreeMap have constructors that accept a comparator:

Set<Player> roster = new TreeSet<>(Comparator.comparing(Player::getName));
Map<String, Integer> reversed = new TreeMap<>(Comparator.reverseOrder());

When a comparator is given, the collection uses it instead of the natural order, both for ordering and for deciding that two elements are duplicates. This is why the key you choose matters: a TreeSet ordered by name alone keeps only one player per name. (Oracle's Comparator documentation describes this relationship.)

Comparator or Comparable?

• Use Comparable when the class has one obvious, permanent order (dates, versions, amounts).
• Use a Comparator when you need several orders, when the order depends on the screen or request, or when you cannot change the class.

A class can have both: a natural order for default use and comparators for alternatives.