How to Create a Comparator in Java

The Java Comparator interface provides a powerful mechanism for ordering objects of user-defined classes. It allows you to define custom sorting logic external to the class itself, offering flexibility and reusability. This tutorial will guide you through the process of creating a Comparator in Java, demonstrating its usage with practical examples.

Understanding the Comparator Interface

The java.util.Comparator interface defines a single method: compare(Object obj1, Object obj2). This method compares two objects and returns an integer indicating their relative order:

Negative value: obj1 is less than obj2.
Zero: obj1 is equal to obj2.
Positive value: obj1 is greater than obj2.

By implementing the Comparator interface and providing a concrete implementation of the compare() method, you define the specific sorting criteria for your objects.

Implementing a Comparator

Let’s say you have a Student class with fields like rollno and name:

class Student {
    int rollno;
    String name;

    // Constructor and other methods...
}

To sort students by rollno in ascending order, you would create a separate class that implements Comparator<Student>:

class SortbyRoll implements Comparator<Student> {
    public int compare(Student a, Student b) {
        return a.rollno - b.rollno;
    }
}

Now, you can use the Collections.sort() method along with your SortbyRoll comparator to sort a list of Student objects:

List<Student> students = new ArrayList<>();
// ... add Student objects to the list ...

Collections.sort(students, new SortbyRoll());

Sorting by Multiple Fields

The Comparator interface allows for sorting based on multiple fields. To sort students first by name and then by age (if names are the same), you can implement the compare() method as follows:

class CustomerSortingComparator implements Comparator<Student> {
    public int compare(Student s1, Student s2) {
        int nameCompare = s1.getName().compareTo(s2.getName());
        return (nameCompare == 0) ? s1.getAge().compareTo(s2.getAge()) : nameCompare;
    }
}

Alternatively, you can use a more concise approach with lambda expressions and method chaining:

students.sort(Comparator.comparing(Student::getName).thenComparing(Student::getAge));

Comparator vs. Comparable

The Comparator interface offers distinct advantages over the Comparable interface:

Feature	Comparator	Comparable
Sorting Logic	External to the class	Within the class
Multiple Sort Orders	Supported	Not supported
Flexibility	More flexible and reusable	Less flexible, tightly coupled

Conclusion

The Comparator interface provides a flexible and powerful way to define custom sorting logic for your objects in Java. By understanding its core functionality and leveraging techniques like sorting by multiple fields and lambda expressions, you can create efficient and maintainable sorting solutions for various scenarios. Using Comparator ensures that your sorting logic remains separate from your object’s core functionality, promoting code reusability and clean design.