Java Comparator Interface Tutorial

In this tutorial, we will explore the Comparator interface in Java, which allows for custom sorting logic. We will demonstrate how to use Comparator to sort a list of custom objects based on various attributes, using the latest Java version to ensure modern practices and features.

Table of Contents

1. Introduction
2. Prerequisites
3. Step-by-Step Guide
   1. Understanding the Comparator Interface
   2. Create a Custom Object
   3. Implement a Comparator for Custom Sorting
   4. Sort the List of Custom Objects
   5. Print the Sorted List
4. Complete Code Example
5. Conclusion

Introduction

The Comparator interface in Java is used to define custom ordering for objects. It provides a way to sort collections of objects by specifying the sorting criteria. In this tutorial, we will demonstrate how to use the Comparator interface to sort a list of custom objects by their attributes.

Prerequisites

Before we start, ensure you have the following:

• Java Development Kit (JDK) installed (latest version preferred)
• An Integrated Development Environment (IDE) such as IntelliJ IDEA or Eclipse

Step-by-Step Guide

Step 1: Understanding the Comparator Interface

The Comparator interface is part of the java.util package and has a single method compare that needs to be implemented. This method takes two objects of the same type and returns an integer:

• 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

Step 2: Create a Custom Object

First, let's create a custom object named Person with attributes name and age.

public 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 + '}';
    }
}

Step 3: Implement a Comparator for Custom Sorting

Next, we will implement a custom comparator to sort the Person objects first by name in a case-insensitive manner and then by age.

import java.util.Comparator;

public class PersonComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        int nameComparison = p1.getName().compareToIgnoreCase(p2.getName());
        if (nameComparison != 0) {
            return nameComparison;
        } else {
            return Integer.compare(p1.getAge(), p2.getAge());
        }
    }
}

Step 4: Sort the List of Custom Objects

Now, we will create a list of Person objects and sort it using our custom comparator.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ComparatorInterfaceExample {
    public static void main(String[] args) {
        // Create a list of Person objects
        List<Person> people = new ArrayList<>();
        people.add(new Person("John", 25));
        people.add(new Person("Alice", 30));
        people.add(new Person("bob", 22));
        people.add(new Person("john", 20));
        people.add(new Person("Alice", 25));

        // Sort the list using the custom comparator
        Collections.sort(people, new PersonComparator());
    }
}

Step 5: Print the Sorted List

Finally, we will print the sorted list to verify that the Person objects are sorted first by name and then by age.

public class ComparatorInterfaceExample {
    public static void main(String[] args) {
        // Create a list of Person objects
        List<Person> people = new ArrayList<>();
        people.add(new Person("John", 25));
        people.add(new Person("Alice", 30));
        people.add(new Person("bob", 22));
        people.add(new Person("john", 20));
        people.add(new Person("Alice", 25));

        // Sort the list using the custom comparator
        Collections.sort(people, new PersonComparator());

        // Print the sorted list
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

Complete Code Example

Here's the complete code example for sorting custom objects using the Comparator interface:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

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 + '}';
    }
}

class PersonComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        int nameComparison = p1.getName().compareToIgnoreCase(p2.getName());
        if (nameComparison != 0) {
            return nameComparison;
        } else {
            return Integer.compare(p1.getAge(), p2.getAge());
        }
    }
}

public class ComparatorInterfaceExample {
    public static void main(String[] args) {
        // Create a list of Person objects
        List<Person> people = new ArrayList<>();
        people.add(new Person("John", 25));
        people.add(new Person("Alice", 30));
        people.add(new Person("bob", 22));
        people.add(new Person("john", 20));
        people.add(new Person("Alice", 25));

        // Sort the list using the custom comparator
        Collections.sort(people, new PersonComparator());

        // Print the sorted list
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

Conclusion

In this tutorial, we demonstrated how to use the Comparator interface to sort a list of custom objects in Java. By implementing a custom comparator, we defined sorting logic based on specific attributes of the Person objects. This approach provides flexibility and efficiency in sorting custom objects.