Java Sort Array Objects Using Comparator Interface

Introduction

The Comparator interface in Java is used to define a custom order for objects. Unlike the Comparable interface, which imposes a natural ordering on the objects of a class, the Comparator interface allows you to define multiple custom orders. This can be particularly useful when you want to sort objects by different attributes or in different orders.

This tutorial will demonstrate how to sort an array of objects using the Comparator interface.

Table of Contents

1. What is the Comparator Interface?
2. Implementing the Comparator Interface
3. Sorting an Array of Objects
4. Complete Example Program
5. Conclusion

1. What is the Comparator Interface?

The Comparator interface is a part of the Java Collections Framework and is used to define a custom order for objects. It has two primary methods:

int compare(T o1, T o2);
boolean equals(Object obj); // Optional

The compare method compares two objects for order. It returns:

• A negative integer, if the first object is less than the second object.
• Zero, if the first object is equal to the second object.
• A positive integer, if the first object is greater than the second object.

2. Implementing the Comparator Interface

To sort an array of objects using the Comparator interface, you need to create a class that implements Comparator and define the compare method.

Example:

Let's consider a Person class with attributes name and age. We will create multiple comparators to sort Person objects by their name and age.

import java.util.Comparator;

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 int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}

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

// Comparator to sort Person objects by age
class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.getAge(), p2.getAge());
    }
}

3. Sorting an Array of Objects

With the Comparator implementations, we can now sort an array of Person objects using the Arrays.sort method and the custom comparators.

4. Complete Example Program

Here is a complete example program that demonstrates how to sort an array of Person objects by their name and age.

Example Code:

import java.util.Arrays;
import java.util.Comparator;

public class SortArrayObjectsWithComparator {
    public static void main(String[] args) {
        // Create an array of Person objects
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };

        // Print the array before sorting
        System.out.println("Before sorting by name:");
        printArray(people);

        // Sort the array by name
        Arrays.sort(people, new NameComparator());

        // Print the array after sorting by name
        System.out.println("After sorting by name:");
        printArray(people);

        // Sort the array by age
        Arrays.sort(people, new AgeComparator());

        // Print the array after sorting by age
        System.out.println("After sorting by age:");
        printArray(people);
    }

    // Method to print the array
    private static void printArray(Person[] array) {
        for (Person person : array) {
            System.out.println(person);
        }
    }
}

Output:

Before sorting by name:
Person{name='Alice', age=30}
Person{name='Bob', age=25}
Person{name='Charlie', age=35}
After sorting by name:
Person{name='Alice', age=30}
Person{name='Bob', age=25}
Person{name='Charlie', age=35}
After sorting by age:
Person{name='Bob', age=25}
Person{name='Alice', age=30}
Person{name='Charlie', age=35}

Explanation:

1. Person Class:

   • The Person class has attributes name and age with corresponding getters.
   • The toString method is overridden to provide a readable string representation of Person objects.

2. NameComparator Class:

   • This class implements the Comparator<Person> interface and overrides the compare method to compare Person objects by their name.

3. AgeComparator Class:

   • This class implements the Comparator<Person> interface and overrides the compare method to compare Person objects by their age.

4. SortArrayObjectsWithComparator Class:

   • The main method demonstrates the use of the NameComparator and AgeComparator classes to sort an array of Person objects.
   • The Arrays.sort method is used to sort the array using the custom comparators.
   • The sorted array is printed after each sort operation.

5. Conclusion

The Comparator interface is used for defining custom orders for objects in Java. By implementing the compare method, you can sort arrays (or collections) of objects based on various attributes. This tutorial has demonstrated how to implement the Comparator interface and sort an array of custom objects using different comparators. Understanding and using this interface effectively is a crucial skill for Java developers, enabling you to manage and manipulate data more flexibly.