Finding Min/Max in an Array with Java

1. Introduction

In this short tutorial, we’re going to see how to find the maximum and the minimum values in an array, using Java 8’s Stream API.

We’ll start by finding the minimum in an array of integers, and then we’ll find the maximum in an array of objects.

2. Understanding the Algorithm

There are many ways of finding the min or max value in an unordered array, and they all look something like:

SET MAX to array[0]
FOR i = 1 to array length - 1
  IF array[i] > MAX THEN
    SET MAX to array[i]
  ENDIF
ENDFOR

We’re going to look at how Java 8 can hide these details from us. But, in cases where Java’s API doesn’t suit us, we can always go back to this basic algorithm.

Because we need to check each value in the array, all implementations are O(n).

3. Finding the Smallest Value

The java.util.stream.IntStream interface provides the min() method that will work just fine for our purposes.

As we are only working with integers, min() doesn’t require a Comparator:

@Test
public void whenArrayIsOfIntegerThenMinUsesIntegerComparator() {
    int[] integers = new int[] { 20, 98, 12, 7, 35 };
    
    int min = Arrays.stream(integers)
      .min()
      .getAsInt();

    assertEquals(7, min);
}

Notice how we created the Integer stream object using the stream() static method in Arrays. There are equivalent stream methods for each primitive array type.

Since the array could be empty, min() returns an Optional, so to convert that to an int, we use getAsInt().

4. Finding the Largest Custom Object

Let’s create a simple POJO:

public class Car {
    private String model;
    private int topSpeed;

    // standard constructors, getters and setters
}

And then we can use the Stream API again to find the fastest car in an array of Cars:

@Test
public void whenArrayIsOfCustomTypeThenMaxUsesCustomComparator() {
    Car porsche = new Car("Porsche 959", 319);
    Car ferrari = new Car("Ferrari 288 GTO", 303);
    Car bugatti = new Car("Bugatti Veyron 16.4 Super Sport", 415);
    Car mcLaren = new Car("McLaren F1", 355);
    Car[] fastCars = { porsche, ferrari, bugatti, mcLaren };

    Car maxBySpeed = Arrays.stream(fastCars)
      .max(Comparator.comparing(Car::getTopSpeed))
      .orElseThrow(NoSuchElementException::new);

    assertEquals(bugatti, maxBySpeed);
}

In this case, the static method stream of Arrays returns an instance of the interface java.util.stream.Stream<T> where the method max requires a Comparator.

We could’ve constructed our own custom Comparator, but Comparator.comparing is much easier.

Note again that max returns an Optional instance for the same reason as before.

We can either get this value, or we can do whatever else is possible with Optionals, like orElseThrow that throws an exception if max doesn’t return a value.

5. Finding the Absolute Minimum and Maximum Values

Sometimes, we may want to find the values in a list based on their absolute value. For example, given the list [-10, 3, -2, 8, 7], the absolute values are [10, 3, 2, 8, 7]. The number closest to zero by absolute value is -2, since 2 is the smallest absolute magnitude. On the other hand, the number with the largest magnitude (farthest from zero) is -10, because its absolute value, 10, is the largest.

The Stream API makes it easy to find the absolute minimum using the min() method, along with a comparator based on absolute values:

void givenIntegerList_whenGetMinAbsolute_thenReturnMinAbsolute() {
    List<Integer> numbers = Arrays.asList(-10, 3, -2, 8, 7);
    int absMin = numbers.stream()
      .min(Comparator.comparingInt(Math::abs))
      .orElseThrow(NoSuchElementException::new);

    assertEquals(-2, absMin);
}

In this example, Comparator.comparingInt(Math::abs) tells the min() method to evaluate values by their absolute magnitudes. The orElseThrow() method throws an exception if the list is empty, ensuring we handle that case safely.

Similarly, we can use the max() method with the same comparator to find the absolute maximum:

void givenIntegerList_whenGetMaxAbsolute_thenReturnMaxAbsolute() {
    List<Integer> numbers = Arrays.asList(-10, 3, -2, 8, 7);
    int absMax = numbers.stream()
      .max(Comparator.comparingInt(Math::abs))
      .orElseThrow(NoSuchElementException::new);

    assertEquals(-10, absMax);
}

6. Finding Maximum Value in an Array Using Recursion

While Java 8 Streams provide an elegant, built-in way to find the maximum value, it’s also a common task to implement this using recursion. This helps in understanding fundamental algorithmic concepts.

A recursive solution can be defined by two components:

• Base Case: If the array (or the segment of the array being checked) has only one element, that element is the maximum.
• Recursive Step: Compare the last element of the array segment with the maximum of the rest of the array segment.

Let’s implement this with a utility method:

public static int findMaxRecursive(int[] array, int n) {
    if (n == 1) {
        return array[0];
    }
     
    return Math.max(array[n - 1], findMaxRecursive(array, n - 1));
}

Accordingly, we compare the last element, the one at index n-1, with the maximum of the rest of the array (size n-1) recursively and return the maximum of the two.

Now, let’s verify it with a JUnit test:

@Test
public void givenIntegerArray_whenFindingMaxUsingRecursion_thenMaxCanBeFoundUsingRecursion() {
    int[] integers = new int[]{20, 98, 12, 7, 35};
    int expectedMax = 98;
    int max = findMaxRecursive(integers, integers.length);
    assertEquals(expectedMax, max);
}

This recursive approach provides an alternative way to solve the maximum element problem, demonstrating an O(n) time complexity similar to the iterative and Stream-based approaches.

7. Conclusion

We saw in this short article how easy and compact it is to find max and min on an array, using the Stream API of Java 8. We also learned how to find the max value in an array using recursion.

For more information on this library, please refer to the Oracle documentation.