Java Comparator Interface
Comparator interface in Java is used to order the objects of user-defined classes. A comparator object is capable of comparing two objects of the same class. Following function compare obj1 with obj2.
Syntax:
public int compare(Object obj1, Object obj2):
Suppose we have an Array/ArrayList of our own class type, containing fields like roll no, name, address, DOB, etc, and we need to sort the array based on Roll no or name?
Methods to Implement Comparator Interface
- Method 1: One obvious approach is to write our own 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 – Comparator interface is used to order the objects of a user-defined class. This interface is present in java.util package and contains 2 methods 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 do the sort() method of Collections class work?
Method of Collections class for sorting List elements is used to sort the elements of 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.
Example:
// 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 GFG
{
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
// 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:
We can use the method mentioned below for achieving same results
students.sort(Comparator.comparing(Student::getName).thenComparing(Student::getAge));
Example:
// 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
| Feature | Comparator | Comparable |
|---|---|---|
| Sorting Logic Location | Defined externally | Defined within the class |
| Multiple Sorting Orders | Supported | Not supported |
| Interface Methods | compare() | compareTo() |
| Functional Interface | Yes | No |
| Usage | Flexible and reusable | Simple and tightly coupled |
Kickstart your Java journey with our online course on Java Programming, covering everything from basics to advanced concepts. Complete real-world coding challenges and gain hands-on experience. Join the Three 90 Challenge—finish 90% in 90 days for a 90% refund. Start mastering Java today!
