Comparable & Comparator

Comparable

Comparable<T> defines the natural ordering of a class. It has a single method compareTo(T o) that returns a negative integer, zero, or positive integer to indicate ordering.

Contract:

• x.compareTo(y) returns negative if x < y
• Returns 0 if x == y
• Returns positive if x > y
• Must be consistent with equals()
• Transitive: if x < y and y < z, then x < z

public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private double gpa;

    public Student(String name, int age, double gpa) {
        this.name = name;
        this.age = age;
        this.gpa = gpa;
    }

    @Override
    public int compareTo(Student other) {
        int nameCompare = this.name.compareTo(other.name);
        if (nameCompare != 0) return nameCompare;
        return Integer.compare(this.age, other.age);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student s = (Student) obj;
        return age == s.age && Double.compare(gpa, s.gpa) == 0 && name.equals(s.name);
    }

    public String getName() { return name; }
    public int getAge() { return age; }
    public double getGpa() { return gpa; }

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

// Usage
import java.util.*;

public class ComparableDemo {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>(Arrays.asList(
            new Student("Charlie", 20, 3.5),
            new Student("Alice", 22, 3.8),
            new Student("Bob", 21, 3.6),
            new Student("Alice", 19, 3.9)
        ));
        Collections.sort(students);
        students.forEach(s -> System.out.println(s));
        // Alice(19, 3.9), Alice(22, 3.8), Bob(21, 3.6), Charlie(20, 3.5)
    }
}

Key points:

• compareTo() is called by Collections.sort(), TreeSet, TreeMap
• Must be consistent with equals() for correct Set/Map behavior
• Use Integer.compare(), Double.compare() instead of subtraction (avoids overflow)

Comparator

Comparator<T> defines custom ordering separate from the class's natural ordering. It has a single method compare(T o1, T o2).

import java.util.*;

public class ComparatorDemo {
    static Comparator<String> byLength = (a, b) -> Integer.compare(a.length(), b.length());

    public static void main(String[] args) {
        List<String> names = new ArrayList<>(Arrays.asList(
            "Charlie", "Alice", "Bob", "David"
        ));

        names.sort(byLength);
        System.out.println("By length: " + names); // [Bob, Alice, David, Charlie]

        names.sort(Comparator.comparingInt(String::length)
                .thenComparing(Comparator.naturalOrder()));
        System.out.println("By length then alpha: " + names);

        names.sort(Comparator.comparingInt(String::length).reversed());
        System.out.println("By length reversed: " + names);
    }
}

Key points:

• Comparator is external to the class — doesn't modify it
• Use when you need multiple sort orders
• compare(o1, o2) vs o1.compareTo(o2)

Lambda Comparators (Java 8+)

Java 8 introduced lambda expressions and method references, making Comparator creation concise.

import java.util.*;

public class LambdaComparatorDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Charlie", "Alice", "Bob", "David");

        names.sort((a, b) -> a.length() - b.length());
        System.out.println("By length: " + names);

        names.sort(Comparator.comparingInt(String::length));
        System.out.println("By length (method ref): " + names);

        names.sort(Comparator.comparingInt(String::length).reversed());
        System.out.println("By length desc: " + names);

        List<String> withNulls = Arrays.asList("b", null, "a", null, "c");
        withNulls.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
        System.out.println("Nulls first: " + withNulls);

        withNulls.sort(Comparator.nullsLast(Comparator.naturalOrder()));
        System.out.println("Nulls last: " + withNulls);

        List<String> mixed = Arrays.asList("Banana", "apple", "Cherry");
        mixed.sort(String.CASE_INSENSITIVE_ORDER);
        System.out.println("Case insensitive: " + mixed);
    }
}

Lambda patterns:

• (a, b) -> a.length() - b.length() — basic lambda
• Comparator.comparingInt(String::length) — method reference
• .thenComparing() — chain conditions
• .reversed() — reverse order
• Comparator.nullsFirst/Last() — handle nulls

Comparator Chaining

Java 8+ provides chaining methods to combine multiple sorting criteria.

import java.util.*;

public class ChainingDemo {
    static class Employee {
        String name;
        String department;
        int age;
        double salary;

        Employee(String name, String dept, int age, double salary) {
            this.name = name; this.department = dept; this.age = age; this.salary = salary;
        }

        @Override
        public String toString() {
            return name + "(" + department + ", " + age + ", $" + salary + ")";
        }
    }

    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<>(Arrays.asList(
            new Employee("Alice", "Engineering", 30, 95000),
            new Employee("Bob", "Marketing", 25, 70000),
            new Employee("Charlie", "Engineering", 35, 110000),
            new Employee("Diana", "Marketing", 28, 80000),
            new Employee("Eve", "Engineering", 25, 90000)
        ));

        employees.sort(Comparator.comparing((Employee e) -> e.department)
                .thenComparing(Comparator.comparingDouble((Employee e) -> e.salary).reversed()));
        System.out.println("By dept, then salary desc:");
        employees.forEach(e -> System.out.println("  " + e));

        employees.sort(Comparator.comparingInt((Employee e) -> e.age)
                .thenComparing((Employee e) -> e.name));
        System.out.println("\nBy age, then name:");
        employees.forEach(e -> System.out.println("  " + e));

        Comparator<Employee> byDeptThenName =
            Comparator.comparing((Employee e) -> e.department)
                      .thenComparing((Employee e) -> e.name);
        employees.sort(byDeptThenName);
        System.out.println("\nBy dept, then name:");
        employees.forEach(e -> System.out.println("  " + e));
    }
}

Chaining methods:

• thenComparing(comparator) — add secondary sort
• thenComparingInt/Double/Long(keyExtractor) — primitive-specific
• reversed() — reverse the comparator

Best practice: Use Comparator.comparing() with method references for clean, type-safe comparators.