Find the Index of the Largest Value in an Array

1. Overview

When working with arrays in Java, one of the everyday tasks we might encounter is finding the index of the largest value in an array.

In this quick tutorial, we’ll walk through several simple and efficient ways to accomplish this task.

2. Introduction to the Problem

Finding the index of the largest element in an array can be useful in various scenarios, such as finding the highest score in a game, the maximum temperature recorded, or any other situation where identifying the peak value is essential.

Let’s say we have an int array:

static final int[] ARRAY = { 1, 2, 7, 10, 8, 6 };

It’s not hard to identify that 10 is the largest element in the above array. So, the corresponding index is 3.

Next, we’ll take ARRAY as an example and explore different ways to find the expected index: 3.

For simplicity, we assume the input array contains a single, unique, largest element. We’ll also skip input validation, such as a null check, and employ unit test assertions to verify each approach’s result.

3. Converting the Array to a List

The first idea is to find the largest element in the array and then get its index. Finding the largest value isn’t a challenge for us. But Java doesn’t offer the indexOf(element) method for arrays to get the index of an element.

We know List has the indexOf() method. So, let’s first convert the int array to a List and then find the index of the largest value:

int indexOfTheMax(int[] array) {
    List<Integer> list = Arrays.stream(array)
      .boxed()
      .toList();
    int max = Collections.max(list);
    return list.indexOf(max);
}

In the code above, we converted the primitive int array to an Integer List using the Stream API. Then, we again employed the Stream API to find the list’s largest value.

It’s worth noting that the max() method returns an Optional object. Therefore, we use the orElse() method to get its value. If the input array is empty, the method returns -1.

If we pass ARRAY or an empty array as inputs to the indexOfTheMax() method, it returns the expected value:

int result = indexOfTheMax(ARRAY);
assertEquals(3, result);
 
result = indexOfTheMax(new int[] {});
assertEquals(-1, result);

This approach solves the problem. However, it walks through the array multiple times.

4. Looping Through the Array

We can traverse the array to find the index of the largest element.

First, let’s look at the implementation:

int indexOfTheMaxByLoop(int[] array) {
    if (array.length == 0) {
        return -1;
    }
    int idx = 0;
    for (int i = 1; i < array.length; i++) {
        idx = array[i] > array[idx] ? i : idx;
    }
    return idx;
}

In indexOfTheMaxByLoop(), we declared and initialized the idx variable to store the result after checking and handling the empty array case. Then, we loop through the array. Whenever we find an element array[i] larger than array[idx], we update idx = i.

Finally, the method returns idx, which holds the index of the largest value.

Next, let’s test the indexOfTheMaxByLoop() method:

int result = indexOfTheMaxByLoop(ARRAY);
assertEquals(3, result);
 
result = indexOfTheMaxByLoop(new int[] {});
assertEquals(-1, result);

As we can see, this approach reports the correct result.

5. Using the Stream API

In the indexOfTheMaxByLoop() method, we solve the problem using a classic for-loop to walk through the input array. Alternatively, we can implement the same logic using the Stream API.

Next, let’s see how to achieve it:

int indexOfTheMaxByStream(int[] array) {
    return IntStream.range(0, array.length)
      .boxed()
      .max(Comparator.comparingInt(i -> array[i]))
      .orElse(-1);
}

As the code shows, we construct an IntStream using the range() method. It’s important to note that this IntStream contains the array’s indexes instead of the array elements.

Then, we pass a Comparator to the max() method, which compares the element value (array[i]). As the result is an Optional we used orElse(-1) to get the index. This isn’t new to us.

Finally, let’s create a test to verify if indexOfTheMaxByStream() does the job:

int result = indexOfTheMaxByStream(ARRAY);
assertEquals(3, result);
 
result = indexOfTheMaxByStream(new int[] {});
assertEquals(-1, result);

As the test shows, indexOfTheMaxByStream() gives the correct result for empty and non-empty array inputs.

6. Conclusion

Finding the index of the largest value in an array is a straightforward task in Java. In this article, we’ve explored different ways to solve this problem.