Introduction

• To define custom ordering logic for objects.

Comparable interface

• When the class has ONE natural ordering
• Want the ordering to be part of the class itself
  • comparison logic lives inside the class
• Implement Comparable<T>
• Override compareTo(T other)

class Student implements Comparable<Student> {
    int age;

    @Override
    public int compareTo(Student o) {
        return Integer.compare(this.age, o.age);
    }
}

// Usage:
Collections.sort(students); // will use compareTo

Comparator (class/lambda)

• For multiple sorting strategies
  • sort differently in different contexts
• Don’t want to modify the class
• Cleaner, more readable code

// Old-school (anonymous class)
Comparator<User> byAge = new Comparator<>() {
    public int compare(User a, User b) {
        return a.getAge() - b.getAge();
    }
};

// Modern (Lambda)
Comparator<User> byAge = 
		(a, b) -> Integer.compare(a.getAge(), b.getAge());
		
// Cleaner modern way (recommended)
students.sort(Comparator.comparingInt(Student::getAge));

Comparator chaining

Sort by age, then name

Comparator<User> cmp =
    Comparator.comparingInt(User::getAge)
              .thenComparing(User::getName);

// clean and modern       
students.sort(
    Comparator.comparing(Student::getAge)
              .thenComparing(Student::getName)
);