Stream recipes: indices, last element and strings

For this lesson, we'll focus on three recipe families: index-aware traversal, last-element access and string operations. We'll keep primitive stream fundamentals, especially chars() versus codePoints(), in Primitive streams: IntStream, LongStream and DoubleStream, and we'll link to collection iteration where a plain list loop is clearer. Interviewers ask these because the code is short, but the trade-offs expose whether you understand stream order, single-use pipelines and when not to force a stream.

01Picture it first: three adapters on the same stream

Picture a stream as a narrow pipe. An index recipe adds a ruler beside the pipe. A last-element recipe drains the pipe and keeps replacing the remembered value. A string recipe converts between text and stream elements at the edges.

The important habit is to name the adapter you are using. Indexing, last-element access and text processing are different problems, even though all three can fit into a stream pipeline.

Fig. 1

Three stream recipes add an index ruler, remember the last element, or convert strings at the edge of a pipeline

02Indices under the hood: range over positions, then look up values

Java streams do not carry an index because Stream<T> is built around elements, not positions. If the source is a List, the clean indexed recipe is to stream the positions with IntStream.range(0, list.size()) and look up each element by index. It reads like a loop, but the index is now part of the pipeline.

import java.util.List;
import java.util.stream.IntStream;

final class IndexedLabelsDemo {
    public static void main(String[] args) {
        List<String> names = List.of("Asha", "Ben", "Mira");

        List<String> labels = IntStream.range(0, names.size())
                .mapToObj(i -> (i + 1) + ". " + names.get(i))
                .toList();

        System.out.println(labels);
    }
}

The output is:

[1. Asha, 2. Ben, 3. Mira]

Notice three things.

• range(0, names.size()) is half-open, so the last index is size() - 1.
• This is a good fit for ArrayList and immutable lists, where get(i) is O(1).
• It is a poor fit for LinkedList, where repeated get(i) can make the traversal O(n²).

If the pair has meaning, I prefer to name it. A tiny record makes downstream code less cryptic than passing around Map.Entry<Integer, T>.

import java.util.List;
import java.util.stream.IntStream;

record Indexed<T>(int index, T value) { }

final class ZipWithIndexDemo {
    static <T> List<Indexed<T>> zipWithIndex(List<T> values) {
        return IntStream.range(0, values.size())
                .mapToObj(i -> new Indexed<>(i, values.get(i)))
                .toList();
    }

    public static void main(String[] args) {
        System.out.println(zipWithIndex(List.of("red", "green", "blue")));
    }
}

The output is:

[Indexed[index=0, value=red], Indexed[index=1, value=green], Indexed[index=2, value=blue]]

The tempting shortcut is an AtomicInteger counter:

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

final class AtomicIndexSmellDemo {
    public static void main(String[] args) {
        AtomicInteger index = new AtomicInteger();
        List<String> labels = List.of("Asha", "Ben", "Mira").stream()
                .map(name -> index.getAndIncrement() + ":" + name)
                .toList();

        System.out.println(labels);
    }
}