Comparing Objects in Java: Comparable and Comparator Interfaces

In Java, comparing objects is a fundamental operation. There are scenarios where you need to determine the order of objects, whether it's sorting a collection, searching for elements, or other operations. Java provides two powerful interfaces, Comparable and Comparator, to facilitate object comparison.

Comparable Interface

The Comparable interface is a part of the java.lang package and it defines a natural ordering for a class. When a class implements the Comparable interface, it provides a default way of comparing its objects based on the specific criteria defined by the class. This natural ordering is useful for sorting objects in collections like arrays and lists.

Example of Using Comparable

Let's create a simple Person class

class Person implements Comparable<Person> {
    private String name;
    private int age;

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

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }

    @Override
    public String toString() {
        return name + " (" + age + " years old)";
    }
}

package org.comparator;
import java.util.Arrays;
public class ComparableExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Nitin", 29),
            new Person("Rob", 52),
            new Person("John", 42),
            new Person("Luke", 54)
        };

        Arrays.sort(people);

        System.out.println("Sorted People:");
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

Output

Sorted People:
Nitin (29 years old)
John (42 years old)
Rob (52 years old)
Luke (54 years old)

In this example, the Person class implements the Comparable interface and overrides the compareTo method. The compareTo method compares Person objects based on their age. We then sort an array of Person objects using Arrays. sort, which uses the natural ordering defined by the compareTo method.

Comparator Interface

The Comparator interface is also a part of the java. util package , and it provides a way to compare objects based on criteria that are external to the object itself. This is particularly useful when you want to sort objects based on multiple criteria or when you don't have control over the class you're comparing.

Example of Using Comparator

Let's create a Movie class and implement a custom Comparator to sort movies by their release year:

class Movie {
    private String title;
    private int releaseYear;

    public Movie(String title, int releaseYear) {
        this.title = title;
        this.releaseYear = releaseYear;
    }

    public String getTitle() {
        return title;
    }

    public int getReleaseYear() {
        return releaseYear;
    }

    @Override
    public String toString() {
        return title + " (" + releaseYear + ")";
    }
}

public class ComparatorDemo {
    public static void main(String[] args) {
        List<Movie> movies = new ArrayList<>();
        movies.add(new Movie("KGF 2 ",2022));
        movies.add(new Movie("OMG 2", 2023));
        movies.add(new Movie("Veer Zara", 2010));

        Collections.sort(movies, new Comparator<Movie>() {
            @Override
            public int compare(Movie movie1, Movie movie2) {
                return movie1.getReleaseYear() - movie2.getReleaseYear();
            }
        });

        System.out.println("Sorted Movies by Release Year:");
        for (Movie movie : movies) {
            System.out.println(movie);
        }
    }
}

Output

Sorted Movies by Release Year:
Veer Zara (2010)
KGF 2  (2022)
OMG 2 (2023)

In this example, we define the Movie class and create a custom Comparator to sort movies by their release year. We use Collections.sort and provide an anonymous class that implements the Comparator interface to perform the sorting.

Best Use Cases

• Comparable: Use the Comparable interface when you have control over the class you want to compare and want to define a default, natural ordering for its instances. This is especially useful for sorting objects in collections.

• Comparator: Use the Comparator interface when you need to compare objects based on criteria that are external to the objects themselves, or when you want to implement custom sorting logic for classes you don't control. It's also useful for sorting objects based on multiple criteria or dynamically changing sort orders.

Difference Between Comparable and Comparator Interface In Java

Comparable	Comparator
Comparable provides a single sorting sequence. In other words, we can sort the collection on the basis of a single element such as id, name, and price.	The Comparator provides multiple sorting sequences. In other words, we can sort the collection on the basis of multiple elements such as id, name, and price etc.
Comparable affects the original class, i.e., the actual class is modified.	Comparator doesn't affect the original class, i.e., the actual class is not modified.
Comparable provides compareTo() method to sort elements.	Comparator provides compare() method to sort elements.
Comparable is present in java.lang package.	A Comparator is present in the java.util package.
We can sort the list elements of Comparable type by Collections.sort(List) method.	We can sort the list elements of Comparator type by Collections.sort(List, Comparator) method.

In conclusion, the Comparable and Comparator interfaces are essential tools in Java for comparing and sorting objects. Whether you need to define natural ordering or implement custom comparison logic, these interfaces provide flexibility and efficiency for working with collections of objects. Understanding when to use each interface is key to writing efficient and maintainable Java code.

Reference

JavaTpoint