In this post we are going to see how to use the Java Streams API to calculate the maximum and minimum of a collection of elements. To do this, we are going to use the max() and min() methods of the Stream class. These methods allow us to obtain the maximum and minimum of a collection of elements, respectively, using a custom comparator.

Suppose we have a list of type List where Exam is a record with two properties name and grade, and we want to obtain the exam with the highest grade and the lowest grade.

public record Exam(String name, Double grade) { }

var exams = Arrays.asList(
        new Exam("Alice", 9.5),
        new Exam("Bob", 6.0),
        new Exam("Charlie", 7.5),
        new Exam("David", 8.0),
        new Exam("Eve", 8.5)
);

In recent versions of Java you can use the max() and min() methods of the Stream class for this purpose by passing a custom comparator and getting an Optional with the result. In case the Java version does not support the max() and min() methods, the collect() method can be used passing a Collector as a parameter, either Collectors.maxBy() or Collectors.minBy(), and in turn a personalized comparator. If you use this last option in a recent version of Java, the IDE itself will suggest changing it to the max() or min() method.

Let's start by creating a custom comparator of type Comparator that allows us to obtain the grades in ascending order.

Comparator byGradeAsc = (e1, e2) -> (int) (e1.grade() - e2.grade());

As an example, this comparator will return a negative number if the grade of the first exam is less than that of the second, zero if they are equal and a positive number if the grade of the first exam is greater than that of the second, for more information you can consult this link to a post that explains how the Comparator interface works.

This comparator can be defined in another way using the comparingDouble() method of the Comparator class which allows us to create a comparator from a function that extracts a double value from an object without the need to write the comparator manually.

Comparator byGradeAscClean = Comparator.comparingDouble(Exam::grade);

In this definition the comparator is told that it must take an object of type Exam, extract the value of the grade property and compare the values ​​using a Double data type.

These two ways are equivalent and can be used interchangeably, the second may be a little more difficult to understand at first, but once you understand it it is easier to write and read.

Now that you have the comparator, all that remains is to use it in the max() and min() methods to obtain the exam with the highest and lowest score, respectively.

var highestGrade = exams.stream().max(byGradeAscClean);
var lowestGrade = exams.stream().min(byGradeAscClean);

In this case, an Optional is obtained with the exam with the highest and lowest score, respectively. In case the exam list is empty, an Optional.empty() will be returned. To obtain the value of the Optional you can use the ifPresent() method that receives a Consumer and executes the code passed to it as an argument if a value exists.

highestGrade.ifPresent(ex -> System.out.println("Highest grade: "   ex.name()   " "   ex.grade()));
lowestGrade.ifPresent(ex -> System.out.println("Lowest grade: "   ex.name()   " "   ex.grade()));

// Output
Highest grade: Alice 9.5
Lowest grade: Bob 6.0

Or simply pass a reference method as an argument to print the value of the Optional, if the Optional is empty nothing will be printed, otherwise the value of the Optional will be printed by calling the toString() method of the Exam object.

highestGrade.ifPresent(System.out::println);
lowestGrade.ifPresent(System.out::println);

// Output
Exam[name=Alice, grade=9.5]
Exam[name=Bob, grade=6.0]

There, this way you can get the maximum and minimum of a collection of elements using the Java Streams API and the Comparator interface.