Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1 Comment
Oldest
Newest