What is difference between Collection.stream().forEach() and Collection.forEach()?

java

stream-api

concurrent-modification

best-practices

byAnton Shumikhin·Nov 17, 2024

The main distinction lies in sequential versus stream based processing. Collection.forEach() is your goto for simple, in-order traversals while Collection.stream().forEach() comes into play when stream operations are required, further setting up for parallelism with parallelStream().forEach().

Example:

// Straight outta collection - sequential and to the point
myList.forEach(element -> System.out.println("Hello, I'm " + element));

// Jump in the stream - allows further operations and opportunities for parallelism
myList.stream().forEach(element -> System.out.println("Hello, I'm " + element + ", living the stream life!"));
// Parallel variant
myList.parallelStream().forEach(element -> System.out.println("Hello, I'm " + element + ", and I'm a parallel universe ninja!"));

Collection.forEach() operates directly on your collection; think quick and direct. Collection.stream().forEach() is for when you want flexible processing e.g. filtering or mapping, potentially in parallel to get those cores working.

Choosing the Right forEach in the Real World

Collection.forEach() is the shoe that fits your feet when you're working with small and simple operations, like printing elements or applying a one-off action to them. It's straightforward, has minimal overhead and maintains the defined order.

When dealing with concurrent or synchronized collections, Iterable.forEach() is your knight in shining armor as it can lock the collection during iteration helping you avoid the dreaded concurrent modification issues.

Stream.forEach(), on the other hand, steps up for the big leagues when you're expecting to perform complex pipeline operations or when order doesn't matter. It wins again with parallel streams as it effortlessly parallelizes operations, a clear winning shot for large datasets or computationally heavy tasks.

However, beware! Modifying elements during iteration using Stream.forEach() could unleash the ConcurrentModificationException. Operators must be non-interfering to prevent playing with Pandora's box.

Points of Distinction and Best Practices

Thread Safety Concerns

To maintain thread safety, Iterable.forEach() locks down the fort during iteration, but with stream().forEach(), you're on your own for maintaining lock protection.

Handling of Concurrent Collections

Iterable.forEach() provides weakly consistent behavior for concurrent collections. This means, it might not reflect concurrent changes that occurred during iteration, aiding performance but losing out on immediate visibility. stream().forEach() is more of a team player and offers better isolation and fewer side-effects during iteration.

Performance Peaks and Troughs

For minor operations, the performance difference between the two methods is close to non-existent. However, when used in a loop that runs more than your backyard squirrel, stream().forEach() can get slow due to object creation overhead.

Gotcha! Order of Execution

Iterable.forEach() executes in the order of the collection, making it a dependable choice. Meanwhile, stream().forEach() can exhibit an undefined order of execution, especially with parallel streams. So, if the order of operations is your dealbreaker, choose wisely!

The Power of Chaining Operations

The bell whistles for stream().forEach() when you need operational chain of commands. With the stream API, you can chain operations like filtering, mapping, and more before concluding with a forEach() making it your Swiss army knife for complex operations.

Example of chaining:

myList.stream()
      .filter(e -> e.isActive())
      .map(e -> new DetailedElement(e))
      .forEach(e -> System.out.println("Element " + e + " reporting for duty!"));

Let's See Some Code!

Concurrent Collections: To Stream or not to Stream

Handling concurrent collections like ConcurrentHashMap using forEach() can be like running with scissors; it can lead to unpredictable results due to the weakly consistent iterator. Opt for stream operations on these collections to maintain better isolation and to eliminate any side effects during iteration.

Side Effects: The Unwanted Guests

Your Lambda within the parenthesis of stream().forEach() must be side-effect-free. That is, it should not affect any state outside its scope. This will shear the wool off the sheep, meaning you will avoid unpredictable results, especially in a parallel stream where shared states can play spoilsport.

Benchmarks: Your Personal Fitness Tracker

When it comes to performance, the fastest method will almost always depend on your JVM, system resources, and the size of data. So, become a scientist and run tests on your target machine to select the best approach. Enter microbenchmarks - your personal fitness tracker, use a tool like JMH (Java Microbenchmark Harness) to help you in your fitness journey!