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

Operations on arrays are essential, and we might need them in any application. Sometimes, they’re hidden behind more convenient interfaces like Collections API. However, this is the basic knowledge we should acquire early in our careers.

In this tutorial, we’ll learn how to find the index of the smallest element in an array. We’ll discuss the methods to do so regardless of the types of the elements, but for simplicity, we’ll use an array of integers.

2. Simple Iteration

The simplest solution is often the best one. This is true for several reasons: it’s easier to implement, change, and understand. Thus, let’s check how we can find the index of the smallest element using a basic for loop:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingForLoop_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Integer.MAX_VALUE;
    int minIndex = -1;
    for (int i = 0; i < array.length; i++) {
        if (array[i] < minValue) {
            minValue = array[i];
            minIndex = i;
        }
    }
    assertThat(minIndex).isEqualTo(expectedIndex);
}

The implementation is quite verbose. However, we aim to resolve the problem and not minimize the number of lines we use. This is a robust and simple solution that is easy to read and change. Also, it doesn’t require a deep understanding of more advanced Java APIs.

The for loop can be replaced by while or, if we feel especially fancy, even do-while. The method we use to iterate over an array isn’t very important.

At the same time, if we’re working with reference types, we can apply this logic only to comparable objects, and instead of the < operator, use the compareTo() method.

3. Two-Step Approach

In another approach, we can split the task into two separate steps: finding the smallest element and finding its index. Although it would be less performant than the first one, it still has the same time complexity.

Let’s modify our first approach:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingForLoopAndLookForIndex_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Integer.MAX_VALUE;
    for (int number : array) {
        if (number < minValue) {
            minValue = number;
        }
    }
    int minIndex = -1;
    for (int i = 0; i < array.length; i++) {
        if (array[i] == minValue) {
            minIndex = i;
            break;
        }
    }
    assertThat(minIndex).isEqualTo(expectedIndex);
}

Here, we need to use two separate loops. At the same time, we can simplify the first one, as we don’t need the index and may break out of the second one earlier. Please note that it doesn’t improve performance compared to the first approach.

4. Primitive Streams

We can eliminate the first loop from the previous approach. In this case, we can use Stream API and, in particular, IntStream:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingIntStreamAndLookForIndex_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
    int minIndex = -1;
    for (int i = 0; i < array.length; i++) {
        if (array[i] == minValue) {
            minIndex = i;
            break;
        }
    }
    assertThat(minIndex).isEqualTo(expectedIndex);
}

IntStreams provide convenient methods for operations on a sequence of primitive values. We used the min() method and converted our imperative loop into a declarative stream.

Let’s try to refactor the second loop into a declarative one:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingIntStreamAndLookForIndexWithIntStream_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
    int minIndex = IntStream.range(0, array.length)
      .filter(index -> array[index] == minValue)
      .findFirst().orElse(-1);
    assertThat(minIndex).isEqualTo(expectedIndex);
}

In this case, we used IntStream.range() for iteration and compared the element to the minimal one. This approach is declarative and should be considered as the way to go. However, the readability of the code suffered, especially for developers with little experience with streams.

We can replace the logic to find the smallest element with a one-liner using the Apache Commons ArrayUtils class:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingIntStreamAndLookForIndexWithArrayUtils_thenGetCorrectResult(int[] array, int expectedIndex) {
    int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
    int minIndex = ArrayUtils.indexOf(array, minValue);
    assertThat(minIndex).isEqualTo(expectedIndex);
}

This makes the solution more readable but requires additional dependencies. If we don’t want to add more dependencies, we can use Lists, as they contain the indexOf() method by default:

@ParameterizedTest
@MethodSource("referenceTypesProvider")
void givenArray_whenUsingReduceAndList_thenGetCorrectResult(Integer[] array, int expectedIndex) {
    List<Integer> list = Arrays.asList(array);
    int minValue = list.stream().reduce(Integer.MAX_VALUE, Integer::min);
    int index = list.indexOf(minValue);
    assertThat(index).isEqualTo(expectedIndex);
}

However, converting an array to a List would affect the space complexity of our solution, increasing it from constant to linear. We won’t consider this approach in further examples, as it doesn’t provide any significant benefits.

5. Arrays and Reference Types

While primitive streams provide a nice API for computations, they’re not applicable for reference types. In this case, we can use the reduce() method:

@ParameterizedTest
@MethodSource("referenceTypesProvider")
void givenArray_whenUsingReduce_thenGetCorrectResult(Integer[] array, int expectedIndex) {
    int minValue = Arrays.stream(array).reduce(Integer.MAX_VALUE, Integer::min);
    int minIndex = ArrayUtils.indexOf(array, minValue);
    assertThat(minIndex).isEqualTo(expectedIndex);
}

The reduce() method takes the identified value; in our case, it’s the Integer.MAX_VALUE and the method reference to the min() method. We use the reduce() method somewhat unconventionally, filtering instead of aggregating. Here, we used ArrayUtils, but the solution with a for loop or filter() would also work.

6. Indexes in Streams

We can use indexes directly with the Stream solution as we did previously with filter(). This way, we can do all the logic inside the reduce() method:

@ParameterizedTest
@MethodSource("primitiveProvider")
void givenArray_whenUsingReduceWithRange_thenGetCorrectResult(int[] array, int expectedIndex) {
    int index = IntStream.range(0, array.length)
      .reduce((a, b) -> array[a] <= array[b] ? a : b)
      .orElse(-1);
    assertThat(index).isEqualTo(expectedIndex);
}

We pass the index of the smallest element along the stream. However, this approach might not be readable and requires a deeper knowledge of the Stream API.

7. Conclusion

Arrays are the most basic data structures in Java. Being comfortable with manipulating and iterating them is a valuable skill, though we don’t usually use arrays directly.

The most straightforward approach is usually the best, as it’s understandable and explicit. Using Streams requires a deeper knowledge of functional programming and might affect the readability of the code in both ways: better or worse. Thus, Stream API should be used with caution.

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