Skip to content

Java Exception Handling

Java Comparator Interface

Last Updated : 12 Jun, 2025

The Comparator interface in Java is used to sort the objects of user-defined classes. The Comparator interface is present in java.util package. This interface allows us to define custom comparison logic outside of the class for which instances we want to sort. The comparator interface is useful when,

We need multiple sorting strategies for a class.
When we want to keep the sorting logic separate from the class.

A comparator object is capable of comparing two objects of the same class. The following function compares obj1 with obj2.

Syntax:

public int compare(Object obj1, Object obj2):

It will return a negative integer if obj1 < obj2.
It will return 0 if both objects are equal.
It will return a positive integer if obj1 > obj2.

When to Use Comparator?

Suppose we have a list of Student objects, containing fields like roll no, name, address, DOB, etc, and we need to sort them based on roll no or name. We use Comparator here to define that logic separately.

Methods to Implement Comparator Interface

Method 1: One obvious approach is to write our sort() function using one of the standard algorithms. This solution requires rewriting the whole sorting code for different criteria, like Roll No. and Name.
Method 2: Using comparator interface: The Comparator interface is used to order the objects of a user-defined class. This interface contains 2 methods that are, compare(Object obj1, Object obj2) and equals(Object element). Using a comparator, we can sort the elements based on data members. For instance, it may be on roll no, name, age, or anything else.

How does the sort() Method of the Collections Class Work?

The sort() method of the Collections class is used to sort the elements of a List by the given comparator.

public void sort(List list, ComparatorClass c)

To sort a given List, ComparatorClass must implement a Comparator interface.

Internally the sort() method does call Compare method of the classes it is sorting. To compare two elements, it asks “Which is greater?” Compare method returns -1, 0, or 1 to say if it is less than, equal, or greater to the other. It uses this result to then determine if they should be swapped for their sort.

Sort Collections by One Field

Example: Sorting By Roll Number

Java

// Using Comparator Interface import java.util.*;  // Define the Student class class Student {     int rollno;     String name;    	// Constructor     Student(int rollno, String name) {         this.rollno = rollno;         this.name = name;     }    	// Method to print Student   	// details in main()     @Override     public String toString() {         return rollno + ": " + name;     } }  // Helper class implementing Comparator interface class SortbyRoll implements Comparator<Student>  {       	// Compare by roll number in ascending order     public int compare(Student a, Student b) {         return a.rollno - b.rollno;     } }  // Driver Class public class Geeks {     public static void main(String[] args)      {       	// List of Students         List<Student> students = new ArrayList<>();                	// Add Elements in List       	students.add(new Student(111, "Mayank"));         students.add(new Student(131, "Anshul"));         students.add(new Student(121, "Solanki"));         students.add(new Student(101, "Aggarwal"));          // Sort students by roll number       	// using SortbyRoll comparator         Collections.sort(students, new SortbyRoll());        	System.out.println("Sorted by Roll Number ");          // Iterating over entries to print them         for (int i = 0; i < students.size(); i++)             System.out.println(students.get(i));       	     } }

Output

Sorted by Roll Number  101: Aggarwal 111: Mayank 121: Solanki 131: Anshul

By changing the return value inside the compare method, you can sort in any order that you wish to. For example: For descending order just change the positions of "a" and "b" in the above compare method.

Note: We can use lambda expression in place of helper function by following the statement as mentioned below:
students.sort((p1, p2) -> Integer.compare(p1.age, p2.age));

Sort Collection by More than One Field

In the previous example, we have discussed how to sort the list of objects on the basis of a single field using the Comparable and Comparator interface But, what if we have a requirement to sort ArrayList objects in accordance with more than one field like firstly, sort according to the student name and secondly, sort according to student age.

Example: Sorting By Multiple Fields (Name, then Age)

Java

// Using Comparator Interface Via  // More than One Field import java.util.*;  // Define the Student class class Student  {     String name;     Integer age;    	// Constructor     Student(String name, Integer age) {         this.name = name;         this.age = age;     }      public String getName() {         return name;     }      public Integer getAge() {         return age;     }    	// Method to print student   	// details in main()     @Override     public String toString() {         return name + " : " + age;     } }  // Comparator in a Helper Class class CustomerSortingComparator    		implements Comparator<Student>  {        	// Compare first by name, then by age     public int compare(Student customer1, Student customer2) {                	// Compare by name first         int NameCompare = customer1.getName().compareTo(           						customer2.getName());                  // If names are the same, compare by age         int AgeCompare = customer1.getAge().compareTo(           						customer2.getAge());                  // Return the result: first by name, second by age         return (NameCompare == 0) ? AgeCompare : NameCompare;     } }  public class ComparatorHelperClassExample  {     public static void main(String[] args)      {         List<Student> students = new ArrayList<>();                students.add(new Student("Ajay", 27));         students.add(new Student("Sneha", 23));         students.add(new Student("Simran", 37));         students.add(new Student("Ankit", 22));       	students.add(new Student("Anshul", 29));       	students.add(new Student("Sneha", 22));              	// Original List         System.out.println("Original List ");          // Iterating List         for (Student it : students) {             System.out.println(it);         }              	System.out.println();          // Sort students by name, then by age       	// using the CustomerSortingComparator         Collections.sort(students, new CustomerSortingComparator());          // Display message only         System.out.println("After Sorting ");          // Iterating using enhanced for-loop         // after Sorting ArrayList         for (Student it : students) {             System.out.println(it);         }     } }

Output

Original List  Ajay : 27 Sneha : 23 Simran : 37 Ankit : 22 Anshul : 29 Sneha : 22  After Sorting  Ajay : 27 Ankit : 22 Anshul : 29 Simran : 37 Sneha : 22 Sneha : 23

Alternative Method: Using Comparator with Lambda

Java 8 introduced a more simple way to write comparators using lambda expressions. We can use the method mentioned below for achieving same result:

students.sort(Comparator.comparing(Student::getName).thenComparing(Student::getAge));

Example:

Java

// Alternative Method import java.util.*;  // Define the Student class class Student {     String name;     Integer age;      // Constructor     Student(String name, Integer age) {         this.name = name;         this.age = age;     }      public String getName() {         return name;     }      public Integer getAge() {         return age;     }      // Method to print student details     @Override     public String toString() {         return name + " : " + age;     } }  public class ComparatorHelperClassExample {     public static void main(String[] args) {         List<Student> students = new ArrayList<>();          students.add(new Student("Ajay", 27));         students.add(new Student("Sneha", 23));         students.add(new Student("Simran", 37));         students.add(new Student("Ankit", 22));         students.add(new Student("Anshul", 29));         students.add(new Student("Sneha", 22));          // Original List         System.out.println("Original List:");          // Iterating List         for (Student it : students) {             System.out.println(it);         }          System.out.println();          // Sort students by name, then by age         students.sort(Comparator.comparing(Student::getName).thenComparing(Student::getAge));          // Display message after sorting         System.out.println("After Sorting:");          // Iterating using enhanced for-loop after sorting ArrayList         for (Student it : students) {             System.out.println(it);         }     } }

Output

Original List: Ajay : 27 Sneha : 23 Simran : 37 Ankit : 22 Anshul : 29 Sneha : 22  After Sorting: Ajay : 27 Ankit : 22 Anshul : 29 Simran : 37 Sneha : 22 Sneha : 23

Comparator vs Comparable

Comparator	Comparable
Sorting logic is defined externally.	Sorting logic is defined within the class (Internally)
Supports multiple sorting orders.	Does not support multiple sorting orders.
Uses the compare() method	Uses the compareTo() method.
It is a functional interface.	It is also a functional interface (since Java 8)
More flexible and reusable	Simple and tightly coupled

Java Exception Handling

R

Rishabh Mahrsee

Improve

Article Tags :

Practice Tags :

Java

Similar Reads

Java is a high-level, object-oriented programming language used to build web apps, mobile applications, and enterprise software systems. It is known for its Write Once, Run Anywhere capability, which means code written in Java can run on any device that supports the Java Virtual Machine (JVM).Java s