Collectors minBy and maxBy

Introduction

The Collectors class has many static utility methods that return an implementation of a Collector. Some examples are toMap, groupingBy, partitioningby, and filtering, flatMapping and teeing. In this post, we will learn about the Collectors minBy and maxBy methods.

Collectors minBy and maxBy

Collectors minBy

Collectors.minBy method returns a Collector that produces the minimal element according to a given Comparator. The minimal element is returned as an Optional.

Collectors maxBy

Collectors.maxBy method returns a Collector that produces the maximal element according to a given Comparator. The maximal element is returned as an Optional.

There are many helper methods to construct a Comparator. The Comparator comparing methods and Comparator nullsFirst and nullsLast explores them in detail.

Collectors minBy and maxBy on a stream

Let us create a stream out of a list and use Collectors.minBy on it to get the minimum element.

List<String> fruits = List.of("apple", "pear", "orange", "grapes");
Optional<String> minElement = fruits.stream()
        .collect(Collectors.minBy(Comparator.naturalOrder()));
System.out.println(minElement); //Optional[apple]

We use the naturalOrder comparator and hence the minimal element will be the fruit which appears first in the lexicographical sorting/arrangement of the fruit names.

To find the maximal element, use Collectors.maxBy.

Optional<String> maxElement = fruits.stream()
        .collect(Collectors.maxBy(Comparator.naturalOrder()));
System.out.println(maxElement); //Optional[pear]

If used on an empty stream, it returns an empty Optional.

maxElement = List.<String>of().stream()
        .collect(Collectors.maxBy(Comparator.naturalOrder()));
System.out.println(maxElement); //Optional.empty

Since it returns an optional we can chain orElse or orElseThrow on it.

System.out.println(fruits.stream()
        .collect(Collectors.maxBy(Comparator.naturalOrder()))
        .orElse("no-fruit-found"));
        
System.out.println(fruits.stream()
        .collect(Collectors.maxBy(Comparator.naturalOrder()))
        .orElseThrow(() -> new RuntimeException("No fruit found")));

Using other comparators

Let us get the smallest and largest fruits in terms of the fruit name (length).

Optional<String> shortestFruit = fruits.stream()
        .collect(Collectors.minBy(Comparator.comparingInt(String::length)));
System.out.println(shortestFruit); //Optional[pear]

Comparator.comparingInt(String::length) arranges the elements from shortest to the longest. Hence, minBy returns ‘pear’.

Optional<String> longestFruit = fruits.stream()
        .collect(Collectors.maxBy(Comparator.comparingInt(String::length)
                .thenComparing(Comparator.reverseOrder())));
System.out.println(longestFruit); //Optional[grapes]

The above comparator has a thenComparing clause to reverse sort the fruits if their lengths are same. Hence, orange will come before grapes. Hence, grapes is the result.

Difference between Collectors.minBy, maxBy and Stream min() and max()

Some IDEs (Intellij is one of them) give a warning or suggestion to replace the above style (using Collectors.minBy or maxBy on a collect) with min() or max() on the stream itself.
It will look like:

minElement = fruits.stream()
        .min(Comparator.naturalOrder());
System.out.println(minElement); //Optional[apple]

maxElement = fruits.stream()
        .max(Comparator.naturalOrder());
System.out.println(maxElement); //Optional[pear]

longestFruit = fruits.stream()
        .max(Comparator.comparingInt(String::length)
                .thenComparing(Comparator.reverseOrder()));
System.out.println(longestFruit); //Optional[grapes]

Here we pass the Comparator to the min and the max method on the stream itself to get the same result.

Stream with nulls

When the input has nulls in them, the Stream min() and max() method could throw a NullPointerException.

fruits = Arrays.asList("apple", "pear", "orange", "grapes", null);

//throws java.lang.NullPointerException
minElement = fruits.stream()
         .min(Comparator.naturalOrder());
System.out.println(minElement);

There is a Comparator utility method called nullsFirst and nullsLast which helps in comparing null and non-null values. Let us use nullsFirst comparator to make null less than any non-null value.

minElement = fruits.stream()
        .min(Comparator.nullsFirst(Comparator.naturalOrder()));
System.out.println(minElement);

Unfortunately, even the above code throws a NullPointerException. The Stream’s min or the max does not allow the result to be null. 

Option #1 – Filter the nulls

Filter out the nulls from the stream before calling min/max.

minElement = fruits.stream()
        .filter(Objects::nonNull)
        .min(Comparator.naturalOrder());
System.out.println(minElement); //Optional[apple]

Option #2 – Move the null to the other end

This is sort of a trick. The Stream’s min method throws a NullPointerException only when the result is null. So, if we want the minimum element, we can use Comparator.nullsLast to sort the nulls at the end. Thus, the minimum result is a non-null value. 

minElement = fruits.stream()
        .min(Comparator.nullsLast(Comparator.naturalOrder()));
System.out.println(minElement); //Optional[apple]

But this does not work if all the elements in the list are null. This works only if there is at least one non-null value.

//both throw NullPointerException
.max(Comparator.nullsLast(Comparator.naturalOrder()));
.min(Comparator.nullsFirst(Comparator.naturalOrder()));

Option #3 – Use Collectors.minBy/maxBy

If the input can have null, we have to use Collectors minBy/maxBy (back to where we have started).

minElement = fruits.stream()
        .collect(Collectors.minBy(Comparator.nullsLast(Comparator.naturalOrder())));
System.out.println(minElement); //Optional[apple]

Important: If we use Comparator.nullsFirst and find the min, it returns an empty optional (and not a null).

minElement = fruits.stream()
        .collect(Collectors.minBy(Comparator.nullsFirst(Comparator.naturalOrder())));
System.out.println(minElement); //Optional.empty

Collectors minBy and maxBy with Collectors groupingBy

Let us say we have an Employee object shown below. Each employee has a name, city, age and salary.

public class Employee{
    private String name;
    private String city;
    private Integer age;
    private Double salary;

    public Employee(String name, String city, Integer age, Double salary) {
        this.name = name;
        this.city = city;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public String getCity() {
        return city;
    }

    public Integer getAge() {
        return age;
    }

    public Double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return name;
    }
}

There is a list of employees.

List<Employee> employees = List.of(
        new Employee("Mike", "London", 34, 12_000D),
        new Employee("Harry", "Paris", 28, 9000D),
        new Employee("Joe", "Berlin", 28, 13_000D),
        new Employee("Perry", "London", 23, 10_500D),
        new Employee("Josh", "London", 32, 11_500D),
        new Employee("Ron", "Berlin", 35, 12_000D));

Let us say we have to find the youngest employee in each city. We can use Collectors groupingBy to group by the city. We use Collectors.minBy as a downstream collector to pick the employee with the smallest value for age (youngest employee).

Map<String, Optional<Employee>> youngestEmployeesByCity = employees.stream()
        .collect(Collectors.groupingBy(Employee::getCity,
                Collectors.minBy(Comparator.comparingInt(Employee::getAge))));
System.out.println(youngestEmployeesByCity);

This produces the result:

{Berlin=Optional[Joe], London=Optional[Perry], Paris=Optional[Harry]}

Finding minimum/maximum when handling nulls

Let us say that the employees can have a null age.

List<Employee> employeesWithNullAge = new ArrayList<>(employees);
employeesWithNullAge.add(new Employee("Smith", "Cape Town", null, 12_500D));
employeesWithNullAge.add(new Employee("Paul", "Cape Town", 21, 10_000D));

If we use the above code, it results in a NullPointerException at the comparingInt method as a null cannot be unboxed to an int. Using comparing would also not work as those Comparators cannot handle null.

//Doesn't work
employeesWithNullAge.stream()
        .collect(Collectors.groupingBy(Employee::getCity,
                Collectors.minBy(Comparator.nullsLast(Comparator
                        .comparingInt(Employee::getAge)))));

Map<String, Optional<Employee>> youngestEmployeesByCity =
       employeesWithNullAge.stream()
               .collect(Collectors.groupingBy(Employee::getCity,
                       Collectors.minBy(
                               Comparator.comparing(Employee::getAge,
                                       Comparator.nullsLast(Comparator.naturalOrder()))
                               )));

{Cape Town=Optional[Paul], Berlin=Optional[Joe], London=Optional[Perry], Paris=Optional[Harry]}

youngestEmployeesByCity = employeesWithNullAge.stream()
        .collect(Collectors.groupingBy(Employee::getCity,
                Collectors.minBy(
                        Comparator.comparing(Employee::getAge,
                                Comparator.nullsFirst(Comparator.naturalOrder()))
                )));
System.out.println(youngestEmployeesByCity);

{Cape Town=Optional[Smith], Berlin=Optional[Joe], London=Optional[Perry], Paris=Optional[Harry]}

Collectors minBy and maxBy with Collectors partitioningBy

Now we will partition the employees into two sets – those with salary less than 12,000 and those with salary at least 12000 and find the youngest employees in both.

Map<Boolean, Optional<Employee>> result = employees.stream()
        .collect(Collectors.partitioningBy(e -> e.getSalary() >= 12000,
                Collectors.minBy(Comparator.comparing(Employee::getAge,
                        Comparator.nullsLast(Comparator.naturalOrder())))));
System.out.println(result);

This outputs, 

{false=Optional[Perry],true=Optional[Joe]}

Perry is the youngest employee among those with salary less than 12000, and Joe is the youngest with salary greater than or equal to 12000.

Conclusion

In this post we saw the Collector minBy and maxBy methods. First we learnt the method signature of minBy and maxBy. Second we used it on a stream to find the minimum and maximum element. Third, we learnt the differences between Collector minBy and maxBy when compared to Stream’s min and max methods. Finally, we used minBy/maxBy on the groupingby and partitioningBy Collectors.

This post builds on top of the Comparator knowledge. So, if you haven’t read the posts on Comparator do check them out.

Useful references

• Min/Max with collectors
• Java2s minBy
• Java2s maxBy