Foreach () vs foreachordered()

 

1 . Overview of forEach()

What It Does: The forEach() method is a terminal operation that accepts a Consumer<T> (a functional interface that performs an action on each element) and applies it to every element in the stream.

Key Point: When used on sequential streams, forEach() iterates over the elements in their encounter order. However, in parallel streams the order in which elements are processed and consumed is not guaranteed. This can mean improved performance but may result in a non-deterministic order of output.

Sequential Example with forEach()

Even though forEach() is designed to be order-agnostic in parallel contexts, when used on a sequential stream it retains the natural ordering:

import java.util.Arrays;

import java.util.List;

public class ForEachSequential {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        

        System.out.println("Using forEach on sequential stream:");

        numbers.stream().forEach(n -> System.out.print(n + " "));

        

        // Expected Output: 1 2 3 4 5

    }

}

Explanation:

A sequential stream created by numbers.stream() processes elements one by one in encounter order.

When printing via forEach(), the output appears as 1 2 3 4 5 since there is no concurrency involved.

2. Overview of forEachOrdered()

What It Does: The forEachOrdered() method is also a terminal operation that accepts a Consumer<T>, but it guarantees that the elements will be processed in the encounter order of the stream—even when the stream is parallel.

Key Point: In a sequential stream, forEachOrdered() behaves the same as forEach(). In parallel streams, however, forEachOrdered() imposes an ordering constraint which may affect performance since it forces the computation to honor the original order.

Sequential Example with forEachOrdered()

import java.util.Arrays;

import java.util.List;

public class ForEachOrderedSequential {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        

        System.out.println("Using forEachOrdered on sequential stream:");

        numbers.stream().forEachOrdered(n -> System.out.print(n + " "));

        

        // Expected Output: 1 2 3 4 5

    }

}

Explanation:

Since the stream is sequential, both forEach() and forEachOrdered() will produce the same output.

3. Difference in Parallel Streams

When you use parallel streams, the difference between forEach() and forEachOrdered() becomes more apparent.

Example: Parallel Stream with forEach() vs. forEachOrdered()

import java.util.Arrays;

import java.util.List;

public class ForEachParallel {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        

        System.out.println("Parallel stream using forEach:");

        numbers.parallelStream().forEach(n -> System.out.print(n + " "));

        // Output might be unordered, e.g.: 3 1 4 2 5

        

        System.out.println("\n\nParallel stream using forEachOrdered:");

        numbers.parallelStream().forEachOrdered(n -> System.out.print(n + " "));

        // Expected Output: 1 2 3 4 5 (maintaining encounter order)

    }

}

Explanation:

Using forEach(): The parallel stream allows concurrent processing of the elements. Because there is no guarantee of ordering, the printed output may come in any order (the exact ordering may vary from run to run).

Using forEachOrdered(): Even though the stream is parallel, forEachOrdered() gathers results while respecting the encounter order. In this example, the output is guaranteed to be 1 2 3 4 5

4 . When to Use Which Method

Use forEach() if:

You do not care about the order of processing/printing in parallel streams.

You are willing to trade order consistency for potential performance gains in a parallel environment.

Use forEachOrdered() if:

Maintaining the encounter order is crucial (for example, when the order of logging or processing matters).

You are working with a parallel stream but must preserve the original ordering.