Difference Between Comparable and Comparator in Java? Example

In Java, sorting and ordering elements within collections is a common requirement in many applications. To achieve this, Java provides two distinct interfaces: Comparable and Comparator. While both interfaces serve the purpose of defining comparison logic, they differ in their usage and implementation. This article aims to clarify the differences between Comparable and Comparator and provide examples to illustrate their usage.

Comparable Interface: The Comparable interface is defined in the java.lang package and contains a single method: compareTo(). By implementing this interface, a class indicates that its instances can be compared and sorted based on a natural order. The natural order is typically defined by the class itself and is inherent to its properties or attributes.

Key Points:

1. The Comparable interface is used for natural ordering.
2. It is typically implemented within the class being compared.
3. The compareTo() method returns a negative integer, zero, or a positive integer to represent the ordering relationship between two objects.

Example: Let's consider a simple example of a Person class implementing the Comparable interface:

java
package thecoderevisited;

import java.util.*;
import java.io.*;

class Person implements Comparable<Person> {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

public class ComparableTest {
    public static void main(String args[]) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("John", 25));
        personList.add(new Person("Alice", 30));
        personList.add(new Person("Mike", 20));

        Collections.sort(personList);

        for (Person person : personList) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}

The output of the above program will be:

Mike - 20
John - 25
Alice - 30

Comparator Interface: The Comparator interface is also defined in the java.util package and contains two methods: compare() and equals(). Unlike Comparable, which is typically implemented within the class being compared, the Comparator interface is designed to provide a separate comparison logic that can be used by multiple classes.

Key Points:

1. The Comparator interface is used for custom ordering or sorting.
2. It is typically implemented in a separate class.
3. The compare() method compares two objects based on custom-defined criteria.
4. Multiple Comparator implementations can be created to compare objects in different ways.

Example: Let's consider a scenario where we want to sort a list of Person objects based on their names using a custom Comparator:

java
package thecoderevisited;

import java.util.*;
import java.io.*;

class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
//creating Comparator based on name
class PersonNameComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
}

public class ComparatorTest {
    public static void main(String args[]) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("John", 25));
        personList.add(new Person("Alice", 30));
        personList.add(new Person("Mike", 20));

        Comparator<Person> nameComparator = new PersonNameComparator();
        Collections.sort(personList, nameComparator);

        for (Person person : personList) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}

The output of the above program will be:

Alice - 30
John - 25
Mike - 20

In the above example, the PersonNameComparator class implements the Comparator interface, providing a custom comparison logic based on the names of Person objects. The compare() method compares the names of two Person objects using the compareTo() method of the String class.

Conclusion: In summary, the Comparable and Comparator interfaces in Java serve different purposes in defining comparison logic. The Comparable interface is implemented within a class to provide a natural ordering, while the Comparator interface is implemented in a separate class to define custom ordering or sorting logic. By understanding the differences between these two interfaces, developers can effectively sort and compare objects based on their specific requirements, enabling flexibility and versatility in their applications.