Comparable vs Comparator

Java offers two distinct ways to define an ordering for objects: implementing the Comparable interface inside the class itself, or writing a separate Comparator. They solve related but different problems, and understanding when to use each is essential for sorting collections and building sorted data structures like TreeSet and TreeMap.

Why it matters

Sorting objects is an everyday task: employees by salary, orders by date, products by price and then by name. Java can only sort objects if it is told how to compare them, and there are two ways to do that. Knowing which to use, and how to chain comparators for several fields, covers nearly every sorting requirement you will meet.

Comparable — One Natural Ordering, Defined Inside the Class

A class implements Comparable<T> by providing a single method: compareTo(T other), which returns a negative number, zero, or a positive number depending on whether "this" object is less than, equal to, or greater than "other". This defines the class's natural ordering — the default order used by Collections.sort(), Arrays.sort(), TreeSet, and TreeMap when no other ordering is specified. A class can only have one natural ordering, because compareTo() is a single fixed method.

Comparator — Multiple External Orderings

A Comparator<T> is a separate object defining a compare(T a, T b) method, written independently of the class being compared. This lets you define as many different orderings as you need — by name, by age, by price descending — without modifying the target class at all, and is especially useful for classes you don't own (like library classes) or classes with no obviously "natural" order.

Modern Comparator Construction

Since Java 8, Comparator is a functional interface, so it is commonly built with lambdas or the static helper methods Comparator.comparing(), .thenComparing(), and .reversed(), which read almost like a sentence describing the sort order.

• Comparable: compareTo(T o), one ordering, defined inside the class, used automatically by sort().
• Comparator: compare(T a, T b), unlimited orderings, defined externally, passed explicitly to sort().

Example

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class Employee implements Comparable<Employee> {
    String name;
    int age;

    Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Employee other) {
        return Integer.compare(this.age, other.age); // natural order: by age
    }

    @Override
    public String toString() {
        return name + "(" + age + ")";
    }
}

public class ComparableComparatorDemo {
    public static void main(String[] args) {
        List<Employee> team = new ArrayList<>(List.of(
                new Employee("Ravi", 34),
                new Employee("Asha", 28),
                new Employee("Meera", 41)
        ));

        java.util.Collections.sort(team); // uses Comparable (natural order: by age)
        System.out.println("By age (natural): " + team);

        team.sort(Comparator.comparing(e -> e.name)); // Comparator: by name
        System.out.println("By name (Comparator): " + team);

        team.sort(Comparator.comparingInt((Employee e) -> e.age).reversed());
        System.out.println("By age descending (Comparator): " + team);
    }
}

By age (natural): [Asha(28), Ravi(34), Meera(41)]
By name (Comparator): [Asha(28), Meera(41), Ravi(34)]
By age descending (Comparator): [Meera(41), Ravi(34), Asha(28)]

Exercise

Sort the employees by salary, highest first. Employees with the same salary should be ordered by name. Then print the names.

Expected output: Ravi, Asha, Zoya (one per line)

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class Employee {
    private final String name;
    private final int salary;

    Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    String getName() { return name; }
    int getSalary() { return salary; }
}

public class SortEmployees {
    public static void main(String[] args) {
        List<Employee> staff = new ArrayList<>(List.of(
                new Employee("Zoya", 50000),
                new Employee("Ravi", 70000),
                new Employee("Asha", 50000)));

        // TODO: sort by salary descending, then by name

        for (Employee e : staff) {
            System.out.println(e.getName());
        }
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class Employee {
    private final String name;
    private final int salary;

    Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    String getName() { return name; }
    int getSalary() { return salary; }
}

public class SortEmployees {
    public static void main(String[] args) {
        List<Employee> staff = new ArrayList<>(List.of(
                new Employee("Zoya", 50000),
                new Employee("Ravi", 70000),
                new Employee("Asha", 50000)));

        staff.sort(Comparator.comparingInt(Employee::getSalary).reversed()
                .thenComparing(Employee::getName));

        for (Employee e : staff) {
            System.out.println(e.getName()); // Ravi, Asha, Zoya
        }
    }
}

Quick quiz

Interview questions