Comparator in Java

Comparator in Java is an interface that belongs to the java.util package. It’s designed to facilitate the comparison of objects, allowing you to create custom sorting rules. This becomes incredibly useful when dealing with complex objects or objects from external libraries that lack a natural order.

Implementing the Comparator Interface

To use a Comparator, you need to implement the compare() method defined in the interface. This method takes two objects as parameters and returns a negative integer, zero, or a positive integer based on whether the first object is less than, equal to, or greater than the second object, respectively.

Following is a basic implementation example:

import java.util.Comparator;

public class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person person1, Person person2) {
        return person1.getAge() - person2.getAge();
    }
}

Sorting with Comparators

Once you’ve defined a Comparator, you can use it to sort a collection of objects. Java provides the Collections class and its sort() method to achieve this.

List<Person> people = new ArrayList<>();
// Add people to the list

Comparator<Person> ageComparator = new AgeComparator();
Collections.sort(people, ageComparator);

Using Lambda Expressions for Conciseness

Java 8 introduced lambda expressions, which make Comparator implementations more concise. The previous example can be rewritten using lambdas:

List<Person> people = new ArrayList<>();
// Add people to the list

Comparator<Person> ageComparator = (person1, person2) -> person1.getAge() - person2.getAge();
Collections.sort(people, ageComparator);

Key Advantages of Using Comparators

• Flexibility: Comparators allow you to sort objects based on criteria that aren’t inherent to the objects themselves.
• Customization: You can create multiple Comparators to sort objects differently without modifying their classes.
• External Sorting: Comparators are particularly useful when dealing with objects from third-party libraries that you can’t modify.

Common Use Cases

Sorting a List of Custom Objects

Suppose you have a list of Product objects that you want to sort by price. By implementing a Comparator for the Product class, you can easily achieve this.

Sorting in Reverse Order

Comparators also allow you to sort objects in reverse order. This can be accomplished by simply reversing the comparison logic.

Practical Example of Using Comparator in Java

Following is an example of how we can use a Comparator in Java to sort a list of custom objects based on a specific criteria. You can copy and paste this code into your Java development environment to see it in action:

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

class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        // Create a list of Student objects
        List<Student> students = new ArrayList<>();
        students.add(new Student("Virat", 22));
        students.add(new Student("Sachin", 20));
        students.add(new Student("Yuvraj", 24));
        students.add(new Student("Ashish", 19));

        // Define a Comparator to sort by age in ascending order
        Comparator<Student> ageComparator = Comparator.comparingInt(Student::getAge);

        // Sort the list using the Comparator
        Collections.sort(students, ageComparator);

        // Print the sorted list
        System.out.println("Students sorted by age:");
        for (Student student : students) {
            System.out.println("Name: " + student.getName() + ", Age: " + student.getAge());
        }
    }
}

Output:

Students sorted by age:
Name: Ashish, Age: 19
Name: Sachin, Age: 20
Name: Virat, Age: 22
Name: Yuvraj, Age: 24

FAQs