How to Access an Iteration Counter in a For Each Loop

1. Overview

While iterating over data in Java, we may wish to access both the current item and its position in the data source.

This is very easy to achieve in a classic for loop, where the position is usually the focus of the loop’s calculations, but it requires a little more work when we use constructs like for each loop or stream.

In this short tutorial, we’ll look at a few ways that for each operation can include a counter.

2. Implementing a Counter

Let’s start with a simple example. We’ll take an ordered list of movies and output them with their ranking.

List<String> IMDB_TOP_MOVIES = Arrays.asList("The Shawshank Redemption",
  "The Godfather", "The Godfather II", "The Dark Knight");

2.1. for Loop

A for loop uses a counter to reference the current item, so it’s an easy way to operate over both the data and its index in the list:

List rankings = new ArrayList<>();
for (int i = 0; i < movies.size(); i++) {
    String ranking = (i + 1) + ": " + movies.get(i);
    rankings.add(ranking);
}

As this List is probably an ArrayList, the get operation is efficient, and the above code is a simple solution to our problem.

assertThat(getRankingsWithForLoop(IMDB_TOP_MOVIES))
  .containsExactly("1: The Shawshank Redemption",
      "2: The Godfather", "3: The Godfather II", "4: The Dark Knight");

However, not all data sources in Java can be iterated over this way. Sometimes get is a time-intensive operation, or we can only process the next element of a data source using Stream or Iterable.

2.2. for Each Loop

We’ll continue using our list of movies, but let’s pretend that we can only iterate over it using Java’s for each construct:

for (String movie : IMDB_TOP_MOVIES) {
   // use movie value
}

Here we need to use a separate variable to track the current index. We can construct that outside of the loop, and increment it inside:

int i = 0;
for (String movie : movies) {
    String ranking = (i + 1) + ": " + movie;
    rankings.add(ranking);

    i++;
}

We should note that we have to increment the counter after it has been used within the loop.

3. A Functional for Each

Writing the counter extension every time we need it might result in code duplication and may risk accidental bugs concerning when to update the counter variable. We can, therefore, generalize the above using Java’s functional interfaces.

First, we should think of the behavior inside the loop as a consumer of both the item in the collection and also the index. This can be modeled using BiConsumer, which defines an accept function that takes two parameters

@FunctionalInterface
public interface BiConsumer<T, U> {
   void accept(T t, U u);
}

As the inside of our loop is something that uses two values, we could write a general looping operation. It could take the Iterable of the source data, over which the for each loop will run, and the BiConsumer for the operation to perform on each item and its index. We can make this generic with the type parameter T:

static <T> void forEachWithCounter(Iterable<T> source, BiConsumer<Integer, T> consumer) {
    int i = 0;
    for (T item : source) {
        consumer.accept(i, item);
        i++;
    }
}

We can use this with our movie rankings example by providing the implementation for the BiConsumer as a lambda:

List rankings = new ArrayList<>();
forEachWithCounter(movies, (i, movie) -> {
    String ranking = (i + 1) + ": " + movies.get(i);
    rankings.add(ranking);
});

4. Adding a Counter to forEach with Stream

The Java Stream API allows us to express how our data passes through filters and transformations. It also provides a forEach function. Let’s try to convert that into an operation that includes the counter.

The Stream forEach function takes a Consumer to process the next item. We could, however, create that Consumer to keep track of the counter and pass the item onto a BiConsumer:

public static <T> Consumer<T> withCounter(BiConsumer<Integer, T> consumer) {
    AtomicInteger counter = new AtomicInteger(0);
    return item -> consumer.accept(counter.getAndIncrement(), item);
}

This function returns a new lambda. That lambda uses the AtomicInteger object to keep track of the counter during iteration. The getAndIncrement function is called every time there’s a new item.

The lambda created by this function delegates to the BiConsumer passed in so that the algorithm can process both the item and its index.

Let’s see this in use by our movie ranking example against a Stream called movies:

List rankings = new ArrayList<>();
movies.forEach(withCounter((i, movie) -> {
    String ranking = (i + 1) + ": " + movie;
    rankings.add(ranking);
}));

Inside the forEach is a call to the withCounter function to create an object which both tracks the count and acts as the Consumer that the forEach operation passes its values too.

5. Conclusion

In this short article, we’ve looked at three ways to attach a counter to Java for each operation.

We saw how to track the index of the current item on each implementation of them for a loop. We then looked at how to generalize this pattern and how to add it to streaming operations.