Module 4: Comparators and Using sort()

Module Overview

Learn about Comparators for flexible object sorting and how to use Java's sorting functionality.

Learning Objectives

• Implement a Comparator to establish custom ordering criteria
• Use Comparators with Collections.sort() and Arrays.sort()
• Create multiple ordering strategies using different Comparators
• Understand the difference between Comparable and Comparator
• Leverage lambda expressions and method references for creating Comparators
• Chain multiple Comparators for complex sorting logic

Understanding Comparators

What is a Comparator?

A Comparator is a functional interface that allows you to define custom comparison strategies separate from the objects being compared. Unlike Comparable (which provides a class's natural ordering), Comparators enable multiple different ordering criteria for the same class.

The interface contains a primary method:

public interface Comparator<T> {
    int compare(T o1, T o2);
    // Optional methods...
}

How compare() Works

The compare method compares two objects and returns:

• Negative integer: if o1 should come before o2
• Zero: if o1 and o2 are considered equal for sorting purposes
• Positive integer: if o1 should come after o2

Basic Comparator Implementation

Here's an example of a Comparator that sorts Person objects by name:

import java.util.Comparator;

public class PersonNameComparator implements Comparator {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
}

Using Comparators

With Collections.sort()

List people = new ArrayList<>();
people.add(new Person("Charlie", 35));
people.add(new Person("Alice", 30));
people.add(new Person("Bob", 25));

// Sort by name using a Comparator
Collections.sort(people, new PersonNameComparator());

// Using lambda expression (Java 8+)
Collections.sort(people, (p1, p2) -> p1.getName().compareTo(p2.getName()));

With Arrays.sort()

Person[] peopleArray = new Person[3];
peopleArray[0] = new Person("Charlie", 35);
peopleArray[1] = new Person("Alice", 30);
peopleArray[2] = new Person("Bob", 25);

// Sort array using a Comparator
Arrays.sort(peopleArray, new PersonNameComparator());

With TreeSet and TreeMap

// Create a TreeSet with a custom comparator
TreeSet sortedByName = new TreeSet<>(new PersonNameComparator());
sortedByName.add(new Person("Charlie", 35));
sortedByName.add(new Person("Alice", 30));
sortedByName.add(new Person("Bob", 25));

Modern Comparator Techniques (Java 8+)

Lambda Expressions

You can use lambda expressions to create concise Comparators:

// Sort by age
Comparator byAge = (p1, p2) -> Integer.compare(p1.getAge(), p2.getAge());

// Sort by name
Comparator byName = (p1, p2) -> p1.getName().compareTo(p2.getName());

Method References

Even more concise with method references:

// Sort by name using method reference
Comparator byName = Comparator.comparing(Person::getName);

Comparator Utility Methods

The Comparator interface provides several utility methods:

// Sort by age in ascending order
Comparator byAge = Comparator.comparing(Person::getAge);

// Sort by age in descending order
Comparator byAgeReversed = Comparator.comparing(Person::getAge).reversed();

// Sort by age, then by name (multiple sort criteria)
Comparator byAgeAndThenName = Comparator
    .comparing(Person::getAge)
    .thenComparing(Person::getName);

Handling null Values

When null values might be involved:

// Handle null Person objects
Comparator nullSafeComparator = Comparator.nullsFirst(byAge);

// Handle null names within Person objects
Comparator byNullSafeName = Comparator.comparing(
    Person::getName, 
    Comparator.nullsFirst(String::compareTo)
);

Comparable vs. Comparator

When to Use Each

• Use Comparable: When there's a clear, default way to order objects of a class
• Use Comparator: When you need multiple ways to order objects, or when you can't modify the class

Best Practices for Using Comparators

• Make comparators consistent with equals when possible
• Use static final instances for common comparators
• Consider using Comparator methods (comparing, thenComparing) for cleaner code
• Handle null values appropriately with nullsFirst or nullsLast
• Avoid excessive object creation with lambda expressions
• Document the ordering criteria implemented by each comparator

Example of Static Final Comparators

public class PersonComparators {
    // Common comparators as static constants
    public static final Comparator BY_NAME = 
        Comparator.comparing(Person::getName);
        
    public static final Comparator BY_AGE = 
        Comparator.comparing(Person::getAge);
        
    public static final Comparator BY_AGE_THEN_NAME = 
        BY_AGE.thenComparing(BY_NAME);
        
    // Prevent instantiation
    private PersonComparators() {}
}

Guided Projects

Mastery Task 5: Devil in the Details

./gradlew -q clean :test

./gradlew -q clean IRT

./gradlew -q clean MasteryTaskFiveTests