“Comparable Vs Comparator in Java” is one of the most important concepts developers must understand when working with object sorting. Although both interfaces are used for sorting collections, they follow different design approaches and serve different purposes.
Many students get confused because both Comparable and Comparator seem to solve the same problem. However, the real difference lies in where the sorting logic is written and how flexible that logic can be.
In this article, we will clearly explain the difference between Java Comparable and Comparator, and understand how each one works. By the end, you will not just know the syntax; you will understand the design thinking behind both interfaces.
TL;DR: Comparable Vs Comparator In Java
Aspect | Summary |
Purpose of Difference | Both interfaces are used for sorting objects in Java collections. The key difference lies in where and how the sorting logic is defined. |
Comparable Interface | Comparable defines the natural or default sorting order inside the class using compareTo(). It supports single sorting criteria and modifies the class definition. |
Comparator Interface | Comparator defines custom sorting logic outside the class using compare(). It allows multiple sorting strategies without changing the original class. |
Implementation Difference | Comparable is sorted using Collections.sort(list). Comparator is sorted using Collections.sort(list, comparator). |
When to Use Which | Use Comparable when objects have a fixed natural order, like roll number or date. Use Comparator when sorting rules are flexible, changeable, or based on multiple fields. |
What Is A Comparable? Read Below
In Java, you can perform sorting with the help of two different interfaces. One of them is the comparable interface. The Java comparable interface allows us to sort the data into different data types.
Whenever we need to compare a set of data members or an object by any of the data members, we can use the Java Comparable interface. Comparable can be used to sort the lists of elements by using any one item.
Comparable uses the compareTo() method. This is the same method name we use when comparing two String objects in Java, but when a class implements Comparable, we define our own comparison logic inside compareTo().
Many developers used it for sorting such cases. But it has one drawback: it can’t sort the list by many data types at the same time. For that purpose, we need to take the help of a Comparator interface.
When Not To Use Comparable:
- Avoid using comparable when the class does not have a clear natural ordering.
- If the sorting rules may change frequently, then you should avoid using comparable.
- For third-party library classes that you don’t own, restrict yourself from using comparable.
- If there are multiple sorting logics equally important, then don’t go for comparable.
How To Implement Comparable In Java?
It is time to know how comparable works. To implement the comparable interface, we need the java.lang.Comparable interface. Let us now have a look at the code implementation of the comparable interface.
import java.util.*;
import java.io.*;
// Declaration Of Comparable Class
class experiment implements Comparable<experiment>{
// Declaring The Fields
int id;
String name;
experiment(int id,String name){
this.id=id;
this.name=name;
}
// Class To Compare Between The Inputs Based On The Ids
public int compareTo(experiment ex){
if(id==ex.id)
return 0;
else if(id>ex.id)
return 1;
else
return -1;
}
}
//Creating a test class to sort the elements
public class Main{
public static void main(String args[]){
// Declaring The Array List
ArrayList<experiment> zap=new ArrayList<experiment>();
// Adding Values To Array List
zap.add(new experiment(11,"CodingZap"));
zap.add(new experiment(10,"ZapOne"));
zap.add(new experiment(15,"Java"));
// Method To Sort
Collections.sort(zap);
// Printing The Vallues Using The For Each Loop
for(experiment ex:zap){
System.out.println(ex.id+" "+ex.name);
}
}
}
Steps Of The Program:
- Here, we need to declare a class that will act as the Comparable. Then, we need to provide the fields.
- We can add different fields of different data types. In this case, we have added two fields.
- One is the Id, which takes an integer value. Another is Name, which takes a string value.
- The values will be provided by the user to store there.
- Now, we need to compare the lists by a certain object or data member.
- Here, we have taken an ID for comparison purposes. If the certain ID is greater than the first one, it will return 1.
- Otherwise, if it is smaller, then it will return -1.
Output
As seen in the above output, the strings or collections are sorted in ascending order or the default order. In case we need a custom order to sort arrays, objects, or other wrapper class objects, then we can make use of the comparator interface.
What Is A Comparator? Read Below
The Comparator interface is another sorting interface in Java. Like Comparable, it is used to sort a list of elements or objects. But the key difference is that it allows us to define sorting logic outside the original class.
With Comparator, we can sort the same object in multiple ways. For example, we can sort students by marks, by name, or by roll number, without modifying the Student class itself. That makes it very flexible.
Comparator uses the compare() method. Inside this method, we write the logic to compare two objects. While beginners sometimes feel it is harder than Comparable, it actually becomes very powerful once you understand how it works.
When Not To Use Comparator:
- You should not use it when the class already has a fixed natural order using Comparable.
- If you are only comparing simple primitive values like int and String directly, then a comparator will not be needed.
- Avoid it when performance is extremely critical and unnecessary object comparison adds overhead.
How To Implement Comparator In Java?
Now, it is time to know how Comparators work. In this case, we need to first develop the Comparator class. In this case, we will use java.util.Comparator interface to sort the objects based on multiple attributes or criteria.
Here, the Comparator can sort the list by many fields at the same time. Here, we have to sort the list by the ID & the Name field.
import java.util.*;
import java.io.*;
// Declaration Of Class Experiment
class experiment{
// Adding The Fields
int id;
String name;
experiment(int id,String name){
this.id=id;
this.name=name;
}
}
// Program For Id Comparator
class IdComparator implements Comparator<experiment>{
public int compare(experiment s1,experiment s2){
if(s1.id==s2.id)
return 0;
else if(s1.id>s2.id)
return 1;
else
return -1;
}
}
// Class For Name Comparator
class NameComparator implements Comparator<experiment>{
public int compare(experiment s1,experiment s2){
return s1.name.compareTo(s2.name);
}
}
class Main{
public static void main(String args[]){
// Creating A List Of Elements
ArrayList<experiment> zap=new ArrayList<experiment>();
zap.add(new experiment(10,"ZapOne"));
zap.add(new experiment(11,"CodingZap"));
zap.add(new experiment(15,"Java"));
System.out.println("Sorting by Ids");
//Using NameComparator to sort the elements
Collections.sort(zap,new IdComparator());
//Traversing the elements of list
for(experiment st: zap){
System.out.println(st.id+" "+st.name);
}
System.out.println();
System.out.println("Sorting by Names");
//Using NameComparator to sort the elements
Collections.sort(zap,new NameComparator());
//Traversing the elements of list
for(experiment st: zap){
System.out.println(st.name+" "+st.id);
}
}
}
Steps Of The Program:
- The program defines a class named Experiment with two fields, ‘Id’ and ‘Name’. A constructor is used to assign values to these fields when an object is created.
- Two separate comparator classes are created, which are IdComparator and NameComparator. Both implement the Comparator<experiment> interface, which means they must override the compare() method.
- IdComparator compares two experiment objects based on their id values and sorts them in ascending order.
- NameComparator compares two experiment objects based on their name using the compareTo() method of String, which sorts them alphabetically.
- Inside the main() method, an ArrayList named ‘zap’ is created, and three experiment objects are added to it with different IDs and names.
Output:
From the above output, we can clearly see that we have performed sorting based on multiple criteria- IDs and Names. In both cases, the results are printed in ascending order.
How To Implement Comparator In Java 8 And Above?
Now, if you are using Java 8 or any other modern versions, then working on Comparator has become much cleaner and easier. The Lambdas removed the need for bulky anonymous classes.
As your mentor, here, I am going to show the use of Lambdas in Java 8 or the latest versions for a comparator.
import java.util.*;
// Simple Student class with 3 fields
class Student {
int rollNo;
String name;
int marks;
// Constructor to initialize student details
Student(int rollNo, String name, int marks) {
this.rollNo = rollNo;
this.name = name;
this.marks = marks;
}
}
public class Main {
public static void main(String[] args) {
// Creating a list to store Student objects
List<Student> list = new ArrayList<>();
// Adding students to the list
list.add(new Student(3, "Alex", 75));
list.add(new Student(1, "Rover", 90));
list.add(new Student(2, "Angella", 85));
// Sorting students by marks in descending order using a lambda expression
list.sort((s1, s2) -> s2.marks - s1.marks);
System.out.println("Implementing Comparator With Lambdas:");
// Printing the sorted list
for (Student s : list) {
System.out.println(s.rollNo + " " + s.name + " " + s.marks);
}
}
}
Steps Of The Program:
- Here, we created a Student class without implementing Comparable. In main(), we created a list of students.
- The s1 and s2 are two student objects being compared.
- The ‘s2.marks – s1.marks’ sorts them in descending order of marks.
- The sort() method internally uses this comparison logic to arrange the list.
Output:
Why Do Students Find Comparable Vs Comparator Difficult To Understand?
In my 10 years of Java mentoring experience, I have noticed students find comparable Vs comparator difficult to understand, despite clearing the basic definition of both of them.
From my interaction with students, I have pointed out some possible reasons why they find this difference confusing. Let us go through the following points.
1) They Feel Identical As Both Are Used For Sorting:
The major reason why students feel this difference is confusing, as they first learn that both Comparable and Comparator help in sorting objects.
Since both involve compare() logic, they assume they do the same thing, which in reality they don’t.
class Student implements Comparable<Student> {
int marks;
public int compareTo(Student s) { // Default Sorting Logic
return this.marks - s.marks; // Sorting by Marks
}
}
Here, sorting logic is built inside the class itself. Students don’t realize this creates a default natural ordering using Comparable. Hence, they got confused with the code logic.
2) Comparator Looks Like A Duplicate Concept:
Many students tell me that when they see Comparator, it feels like an unnecessary repetition of Comparable, because it also defines comparison logic. This shows students don’t dive deep into the concepts.
import java.util.Comparator;
class NameComparator implements Comparator<Student> {
public int compare(Student s1, Student s2) {
return s1.marks - s2.marks; // Implementing Custom Sorting Logic
}
}
This logic exists outside the Student class. Students get confused because they don’t see why Java needs two different ways to compare objects.
3) “Inside Vs Outside” Logic Is Hard To Visualize:
The real conceptual difference is where the sorting rule lives, whether it is inside the class for Comparable or outside the class due to Comparator. This design idea is abstract for beginners.
import java.util.Comparator;
class NameComparator implements Comparator<Student> {
Collections.sort(studentList); // Uses Comparable
Collections.sort(studentList, new NameComparator()); // Uses Comparator
}
Both lines sort the list, so students assume both mechanisms are the same. But, they miss the deeper point; Comparable defines a natural order, while Comparator allows multiple custom orders.
What Is The Differences Between The Comparable Vs Comparator In Java?
Now that you have clearly understood how both Comparable and Comparator work individually, let us place them side by side to highlight their differences. The following comparison table will help you quickly identify when to use Comparable and when to prefer Comparator.
Comparable In Java | Comparator In Java |
It can sort the list with the help of only one field at the same time. | Comparator can sort the list with the help of many fields at the same time. |
It changes the original class elements. The actual class is being modified here. | It doesn’t change the original class. The actual class remains the same as earlier. |
Java.lang package should be used to implement Comparable. | Java.utill package should be used to implement a Comparator. |
It uses the compareTo() method to compare two fields & sort them. | It uses the compare() method to compare two fields & sort them. |
General Syntax: Collections.sort(listname); | General Syntax: Collections.sort(listname, comparator) |
Comparison behavior sometimes differs between primitive types and object types. If you would like to refresh your understanding of the types that Java uses under the hood, see Java data types overview.
When To Use Comparable and Comparator In Your Java Code?
The use of the comparable interface and the comparator interface depends upon the requirements of your code or sorting logic. Below are some of the cases that tell us where to use comparable and comparator in Java.
Use of Comparable Interface
- You can use the comparable interface when you want to establish a natural sorting order or default sorting order for the objects based on their intrinsic properties. For example, a list of dates in a class may be sorted in chronological order using the comparable object.
- The comparable interface in Java is used in cases where you require a single criterion or attribute to sort objects.
- The comparable interface is suitable when the sorting sequence logic is linked closely to the particular class.
Use of Comparator Interface
- The comparator interface can be used when we need to perform custom sorting logic on an object.
- Here, you can have multiple criteria or attributes to sort objects. For example, sorting of an employee can be done based on their name, department, and branch.
- The comparator interface is complex to implement, but it provides flexibility as you can have external properties or classes while sorting the contents or objects.
Comparable and Comparator are not just for sorting lists; they also power ordered collections like priority queues. If you want to see how Java uses comparison logic in a real data structure, check out Priority Queue in Java.
The Difference In Design Thinking: Comparable Vs Comparator In Java
From my experience, I have noticed that students often face troubles in Comparable Vs Comparator, just because they try to find the difference in the syntax.
To truly understand them, you must think like a software designer, not just a programmer. For that, you have to develop the difference in their design. When I explain this to students, I tell them to think in the following way.
Comparable is used when a class knows how it should naturally be ordered. For example, a Student might naturally be sorted by roll number. That logic belongs inside the class itself.
That is why Comparable is implemented by the class and overrides compareTo().
On the other hand, a comparator is used when sorting is external or changeable. Suppose you want to sort students by marks, then by name, then by age. Should all those rules live inside the Student class?
No. That would make the class messy and tightly coupled to too many sorting decisions.
So here is the difference in design thinking:
- Use Comparable when sorting logic is fixed and natural.
- Use a Comparator when sorting logic is flexible and changeable.
This approach follows clean code principles and separation of concerns, something every serious Java developer must understand.
Common Mistakes Students Make With Comparator Vs Comparable In Java:
While working with comparable and comparator in Java, I have seen students make the following mistakes in their exams. Here, I am going to highlight them so that you can avoid them during your exams.
- Sometimes, students implement Comparable when multiple sorting rules are required, which is illogical.
- Oftentimes, students forget to maintain consistency between equals() and compareTo(), which creates errors in the code.
- I have seen students write very complex ‘compare()’ logic that reduces the readability of the code and hence gets a lower score.
- Sometimes, students use Java 8 or the latest versions, but don’t go with the Lambda or newer implementation way for the comparator.
- Oftentimes, students modify business objects just to satisfy temporary sorting needs, which is unnecessary.
From my experience, I can say that once students shift their thinking from “How to sort?” to “Where should sorting logic live?”, everything becomes clear.
Conclusion:
Understanding “Comparable Vs Comparator in Java” is essential for writing clean and flexible sorting logic.
Comparable defines natural ordering inside the class, whereas Comparator allows custom and multiple sorting strategies outside the class. If your object has a fixed natural order, Comparable is the right choice.
If you need flexibility or multiple sorting rules, Comparator is the better option. Once you understand where sorting logic should live, choosing between Comparable and Comparator becomes simple and logical, not confusing.
Takeaways:
- Java Programming offers us two types of interfaces to sort objects in collections or wrapper classes. These interfaces are called comparable and comparator.
- A comparable interface is used in the natural ordering of objects and is used when we need to sort data based on the intrinsic properties of the objects present in a class.
- A Comparator interface, on the other hand, is used when we need to perform custom ordering of objects and sort data based on external sorting logic.
- Comparable uses a single criterion to sort objects, whereas Comparator uses multiple sorting criteria to sort objects.
- Both of these interfaces see their uses in a variety of real-world applications.
Frequently Asked Questions:
1) What is the main difference between Comparable and Comparator?
Comparable defines the natural sorting order inside the class using compareTo(). Comparator defines custom sorting logic outside the class using compare(). In simple terms, Comparable is fixed sorting, and Comparator is flexible sorting.
Is Comparator a functional interface?
Yes, Comparator is a functional interface because it has only one abstract method, which is compare(). Since Java 8, it can be used with lambda expressions, and it also has many default and static helper methods like comparing() and reversed().
Does Comparable override equals()?
No, Comparable does not override equals(). It only requires the implementation of the compareTo() method. However, it is strongly recommended that the compareTo() logic should be consistent with equals() to avoid unexpected behavior in collections.
