Comparator vs Comparable: Unlocking the Power of Custom and Natural Sorting in Java Vaishnavi Tech Talks

Table of Contents

Comparator vs Comparable in Java

In Java, sorting objects could be a common task, and two interfaces give the implies to realize this: ComparableandComparator.
Whereas both interfaces serve the reason of comparing objects, they offer diverse approaches and utilize cases.
Understanding the refinements between these two interfacing is crucial for choosing the right one based on the specific necessities of your application.
In this article, we are going investigate the key contrasts, examples, and best practices for utilizing Comparable and Comparator.

The Comparable Interface

The Comparable interface is utilized after you need to characterize a natural ordering for the objects of a class.
It permits objects to be compared to each other utilizing the compareTo(T o) method, which is executed inside the class.
When a class executes Comparable, it gives a way for objects of that class to be sorted in a significant way concurring to their natural order.
This sorting is generally based on one or a couple of attributes.

Example of Comparable

Consider a class Person where we need to sort people by their age:

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

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

public int getAge() {
return age;
}

public String getName() {
return name;
}

@Override
public int compareTo(Person other) {
return Integer.compare(this.age, other.age); // Sorting by age
}

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

In this case, the Person class actualizes Comparable and overrides the compareTo() method to compare people by age.

The Comparator Interface

The Comparator interface gives a more adaptable and external way of comparing objects.
Not at all like Comparable, which needs adjusting the class whose objects you need to compare, Comparator permits you to characterize a comparison strategy outside of the class.
Typically especially valuable once you have to be sort objects in numerous ways (by distinctive attributes) or after you cannot adjust the class itself.

Example of Comparator

Consider the same Person class, but this time, we need to sort people by their name rather than their age. We are able accomplish this using a Comparator:

import java.util.*;

class NameComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName()); // Sorting by name
}
}

Here, NameComparator actualizes Comparator and gives custom sorting based on the name of the Person.

Difference Between Comparator and Comparable in Java

In Java, both Comparator and Comparable are utilized to compare objects and energize sorting. Be that because it may, they serve particular purposes and have specific highlights. Below could be a detailed comparison between the two:

Aspect	Comparable	Comparator
Definition	`Comparable` is used to define a natural ordering for objects of a class. It is implemented within the class itself.	`Comparator` is used to define an external sorting strategy for objects. It is defined outside the class being compared.
Location of Implementation	Implemented within the class whose objects need to be compared.	Implemented externally, in a separate class or as an anonymous class.
Method	`compareTo(T o)` is the method used to compare objects. It returns an integer value indicating the order.	`compare(T o1, T o2)` is the method used to compare two objects. It also returns an integer value indicating their order.
Flexibility	Less flexible; the class itself dictates its sorting order.	More flexible; allows for multiple sorting strategies and can be applied to different types of objects.
Sorting Criteria	Typically uses one criterion for sorting (e.g., age, name, salary).	Can use multiple criteria to compare objects (e.g., first by age, then by name).
Use Case	Best suited for cases where the class should have a single, default sorting order.	Best suited for situations where multiple sorting orders are required or when the class should not be modified.
Modification of Class	Requires modification of the class itself.	Does not require modification of the class being compared.
Sorting Direction	Sorting direction is generally fixed (ascending by default). To change the order, you need to modify the class.	Provides flexibility to define reverse sorting or custom sorting logic.
Common Usage	Sorting objects by a natural attribute (e.g., sorting a list of `Person` objects by their age).	Sorting with custom logic or different criteria (e.g., sorting a list of `Employee` objects by salary first, then by name).
Example	`Person implements Comparable<Person>` and compares persons by their age.	`PersonComparator implements Comparator<Person>` and compares persons by their name or salary.
Built-in Methods	Java provides built-in methods like `Collections.sort()` and `Arrays.sort()` which automatically use `compareTo()`.	Java provides `Comparator` utility methods such as `reversed()`, `thenComparing()`, etc., to build more complex comparison logic.