Java 8 – Find Maximum and Minimum Values Using Lambda Expressions

Introduction

Java 8 introduced lambda expressions and the Stream API, enabling developers to perform operations on collections more efficiently and concisely. One common task is finding the maximum and minimum values in a list or collection. Traditionally, this required iterating over the collection manually, but with the Stream API, you can achieve this in a much simpler and more readable way using lambda expressions.

In this guide, we’ll explore how to find the maximum and minimum values from a list using lambda expressions in Java 8.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Finding Maximum and Minimum Values in a List
• Advanced Considerations
• Conclusion

Problem Statement

You may often need to determine the maximum or minimum value in a list of numbers or objects based on specific criteria. Manually iterating through the collection to find these values can be cumbersome. The goal is to create a Java program that efficiently finds the maximum and minimum values in a list using Java 8’s Stream API and lambda expressions.

Example:

• Input: A list with elements [3, 5, 7, 2, 8].
• Output: The maximum value is 8, and the minimum value is 2.

Solution Steps

1. Create a List: Define a list of numbers or objects from which you want to find the maximum and minimum values.
2. Use the Stream API: Utilize the max() and min() methods along with lambda expressions to find the maximum and minimum values.
3. Handle Optional Values: Since max() and min() return Optional values, handle them appropriately.

Java Program

Finding Maximum and Minimum Values in a List

Here’s a simple example that demonstrates how to find the maximum and minimum values from a list of integers using the Stream API and lambda expressions:

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

/**
 * Java 8 - Find Maximum and Minimum Values Using Lambda Expressions
 * Author: https://www.rameshfadatare.com/
 */
public class FindMaxMinExample {

    public static void main(String[] args) {
        // Step 1: Create a list of integers
        List<Integer> numbers = Arrays.asList(3, 5, 7, 2, 8);

        // Step 2: Find the maximum value using the Stream API and lambda expressions
        Optional<Integer> maxNumber = numbers.stream()
            .max(Integer::compareTo);

        // Step 3: Find the minimum value using the Stream API and lambda expressions
        Optional<Integer> minNumber = numbers.stream()
            .min(Integer::compareTo);

        // Step 4: Display the maximum and minimum values
        maxNumber.ifPresent(max -> System.out.println("Maximum value: " + max));
        minNumber.ifPresent(min -> System.out.println("Minimum value: " + min));
    }
}

Output

Maximum value: 8
Minimum value: 2

Explanation

• List Creation: The list numbers is created with integer elements.
• Finding Maximum Value: The max() method finds the maximum value in the stream. Integer::compareTo is a method reference used to compare elements.
• Finding Minimum Value: The min() method finds the minimum value in the stream. Like max(), it uses Integer::compareTo for comparison.
• Handling Optional Values: The max() and min() methods return Optional objects, which may or may not contain a value. The ifPresent() method is used to print the maximum and minimum values if they are present.

Advanced Considerations

• Custom Objects: If you’re working with custom objects, you can use lambda expressions or method references to specify the comparison logic. For example, finding the product with the highest price:

  Optional<Product> maxPriceProduct = products.stream()
      .max(Comparator.comparing(Product::getPrice));
  

• Empty Lists: If the list is empty, the max() and min() methods will return an empty Optional. You can handle this case using Optional.orElse() or Optional.orElseThrow():

  int maxValue = maxNumber.orElseThrow(() -> new RuntimeException("No max value found"));
  

• Comparing Multiple Fields: If you need to compare multiple fields, you can use Comparator.thenComparing():

  Optional<Product> maxProduct = products.stream()
      .max(Comparator.comparing(Product::getPrice)
                     .thenComparing(Product::getName));
  

Conclusion

Finding the maximum and minimum values in a collection is a common requirement, and with Java 8’s Stream API and lambda expressions, this task becomes straightforward and efficient. Whether you’re working with simple lists of numbers or more complex custom objects, the max() and min() methods provide a clean, readable way to determine the extremes in your data. This approach not only simplifies your code but also makes it more expressive and maintainable.