How does Comparator work in Java?

Introduction

Sometimes when working on a project the need arises to sort some type of collection of objects, for this you may think that it is necessary to implement our own sorting algorithms, but this is somewhat unnecessary, although it does not hurt to know how they work. For example, if you have an array of integers, you can use the Arrays.sort() method that accepts an array of primitives and sorts it in ascending order, taking advantage of the fact that it is not necessary to assign the result to a new variable, since the method modifies the original array.

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));

// Output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

This also applies when you have a collection of custom objects, for example, a record of type Movie, but if we see the Arrays.sort() method it does not accept an array of objects of this type, so it must be use the sort() method that accepts as parameters an object of type T and an object of type Comparator which is a functional interface. This interface is very important, as many other methods within Java use it to compare objects in a custom way. For example, the Collections.sort() method or the sort() method of a List object, even Streams accept a Comparator to sort the elements.

What is Comparator?

The functional interface Comparator (being functional it can be written as a lambda expression) is an interface that allows you to compare two objects of type T, so it is used to compare integers, strings, custom objects, etc The interface has several static and default methods, but the important thing is the compare() method, which is the one that must be implemented to compare two objects. compare() receives two objects of type T and returns an integer. The method signature is as follows:

int compare(T o1, T o2);

This method returns a negative number if o1 is less than o2, zero if they are equal and a positive number if o1 is greater than o2, normally it returns -1, 0 or 1 respectively.

What does it mean that one object is less than, equal to, or greater than another?

Let's analyze what the compare() method returns since the ordering of the objects depends on this. It is important to consider that the meaning of what the method returns is relative, that is, if you want to order ascending or descending. It depends on the situation and how it is implemented. Let's consider the following record for each example:

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));

// Output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

• If the first argument is less than the second, a negative number is returned. For example, to sort movies by release year, -1 can be returned when movie a is smaller than movie b:

int compare(T o1, T o2);

• If the first argument is greater than the second, a positive number is returned. For example, to sort movies by budget, 1 can be returned when movie a is larger than movie b:

public record Movie(
        String name,
        List<String> actors,
        int budget,
        int year
) {
}

• If the first argument is equal to the second, zero is returned. For example, to sort movies by the number of actors, 0 can be returned when movie a equals movie b:

// a < b -> -1
a.year() < b.year() -> -1

Using Comparator

Suppose we have the following movies inside an object of type List:

// a > b -> 1
a.budget() > b.budget() -> 1

If you want to order the movies by year of release in ascending order, you can create an object of type Comparator and override the compare() method, and then pass this object to the list's sort() method:

// a == b -> 0
a.actors().size() == b.actors().size() -> 0

It can also be implemented as an anonymous class within the sort() method:

Movie movie1 = new Movie("The Godfather", Arrays.asList("Marlon Brando", "Al Pacino"), 6000000, 1972);
Movie movie2 = new Movie("The Godfather: Part II", Arrays.asList("Al Pacino", "Robert De Niro"), 13000000, 1974);
Movie movie3 = new Movie("The Shawshank Redemption", Arrays.asList("Tim Robbins", "Morgan Freeman"), 25000000, 1994);
Movie movie4 = new Movie("The Dark Knight", Arrays.asList("Christian Bale", "Heath Ledger"), 185000000, 2008);

List<Movie> movies = Arrays.asList(movie1, movie2, movie3, movie4);

Or more concisely using a lambda expression directly in the sort() method:

Comparator<Movie> comparatorByYear = new Comparator<Movie>() {
    @Override
    public int compare(Movie o1, Movie o2) {
        return o1.year() - o2.year();
    }
};

movies.sort(comparatorByYear);

Any of these implementations will sort the list ascending by release year. If you want to sort in descending order, you can change the order of the arguments in the lambda expression, or add a negative sign in the subtraction:

movies.sort(new Comparator<Movie>() {
    @Override
    public int compare(Movie o1, Movie o2) {
        return o1.year() - o2.year();
    }
});

Some other examples of how a list of custom objects can be sorted are:

• Order the movies by the number of actors in ascending order (fewer actors to more actors):

movies.sort((p1, p2) -> p1.year() - p2.year());

• Sort movies by budget in descending order (highest budget to lowest budget):

movies.sort((p1, p2) -> p2.year() - p1.year());
// o
movies.sort((p1, p2) -> - (p1.year() - p2.year()));

• Sort movies by name in ascending order:

movies.sort((p1, p2) -> p1.actors().size() - p2.actors().size());

Among other examples, we can have the case where it is necessary to sort a list of integers in descending order,

movies.sort((p1, p2) -> p2.budget() - p1.budget());
// o 
movies.sort((p1, p2) -> - (p1.budget() - p2.budget()));

To do this, you can also use the static method Comparator.reverseOrder() that returns a comparator that orders the elements in descending order and Comparator.naturalOrder() that orders the elements in ascending order.

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));

// Output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Use Integer.compare()

Within Java there are already methods that allow us to perform this type of comparisons in an efficient way, for example Integer.compare() which compares two integers and returns a negative number if the first argument is less than the second, zero if are equal and a positive number if the first argument is greater than the second. If we analyze how this method works, we can see that it is similar to what has been explained above, and returns exactly what the compare() method of the Comparator interface requires. The implementation of Integer.compare() is as follows:

int compare(T o1, T o2);

So, if you want to sort the movies by year of release in ascending order, you can use Integer.compare():

public record Movie(
        String name,
        List<String> actors,
        int budget,
        int year
) {
}

Using reference methods

Sometimes reference methods can be used to perform comparisons differently than before, for example, to sort a list of integers in ascending order:

// a < b -> -1
a.year() < b.year() -> -1

Integer is not the only class that has a compareTo() method, for example String has a compareTo() method that compares two strings lexicographically, so it can be used to sort a list of strings, or even use CharSequence with its compare() method (technically represents a sequence of characters).

// a > b -> 1
a.budget() > b.budget() -> 1

Returning to the example of movies, if you want to sort the movies by year of release in ascending order, you can use the comparingInt() method as a reference method:

// a == b -> 0
a.actors().size() == b.actors().size() -> 0

Or to compare according to a String type attribute, in this case the name of the movie:

Movie movie1 = new Movie("The Godfather", Arrays.asList("Marlon Brando", "Al Pacino"), 6000000, 1972);
Movie movie2 = new Movie("The Godfather: Part II", Arrays.asList("Al Pacino", "Robert De Niro"), 13000000, 1974);
Movie movie3 = new Movie("The Shawshank Redemption", Arrays.asList("Tim Robbins", "Morgan Freeman"), 25000000, 1994);
Movie movie4 = new Movie("The Dark Knight", Arrays.asList("Christian Bale", "Heath Ledger"), 185000000, 2008);

List<Movie> movies = Arrays.asList(movie1, movie2, movie3, movie4);

Sort by multiple attributes

Sometimes you may need to sort a list of objects by multiple attributes, for example, if you want to sort movies by year of release in ascending order and by budget in descending order, you can use the thenComparing() method that receives a Comparator and is responsible for ordering by multiple attributes. For example, if there are two movies a and b, with the same release year, they will be ordered by budget.

Comparator<Movie> comparatorByYear = new Comparator<Movie>() {
    @Override
    public int compare(Movie o1, Movie o2) {
        return o1.year() - o2.year();
    }
};

movies.sort(comparatorByYear);

Conclusions

Comparators are useful in Java on many occasions, since they allow you to compare objects in a personalized way, and not only that, but they can also be used in many Java collection methods, and even have more than one comparator to sort in different ways. Either way, you can consult the Comparator documentation within the IDE or in the official Java documentation to see what methods can be used and how they can be implemented.

The above is the detailed content of How does Comparator work in Java?. For more information, please follow other related articles on the PHP Chinese website!