Understanding the Stream.peek() Method in Java 8 and Java 9

What are the differences between the Stream.peek() method in Java 8 and Java 9, and why does my code not produce the expected output?

import java.util.Arrays;
import java.util.List;

public class Test_Q3 {

    public static void main(String[] args) {
        List<Integer> values = Arrays.asList(1, 2, 3);
        values.stream()
              .map(n -> n * 2)
              .peek(System.out::print)
              .count();
    }
}

The Stream.peek() method in Java allows for inspecting elements at various stages within a stream pipeline. However, its behavior and expectations can sometimes lead to confusion, especially for those transitioning from Java 8 to Java 9 due to potential differences in execution context and stream handling.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Test_Q3 {
    public static void main(String[] args) {
        List<Integer> values = Arrays.asList(1, 2, 3);
        List<Integer> result = values.stream()
                                   .map(n -> n * 2)
                                   .peek(System.out::print)
                                   .collect(Collectors.toList());
    }
}

Causes

• The Stream.peek() method is an intermediate operation that does not produce a visible output unless the stream is terminated. In the provided code, count() is invoked as a terminal operation, which correctly triggers the stream pipeline but does not print anything to the console upon direct execution due to how peek() is utilized.
• In Java 9, the behavior of peek() is not different from Java 8, but the overall streams API has seen enhancements, making streams slightly more efficient.

Solutions

• To see the output from System.out::print, ensure the stream is processed in a way that executing peek() produces side effects. For example, you could collect the results rather than just calling count():
• ```java import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Test_Q3 { public static void main(String[] args) { List<Integer> values = Arrays.asList(1, 2, 3); List<Integer> result = values.stream() .map(n -> n * 2) .peek(System.out::print) .collect(Collectors.toList()); } } ```

Mistake: Using peek() and expecting it to output values when the stream is not terminally operated upon.

Solution: Always remember that intermediate operations like peek() do not execute until a terminal operation is invoked.

Mistake: Forgetting that peek() is mainly for debugging and can lead to side effects in production code.

Solution: Use peek() primarily for debugging purposes while developing and replace with proper logging for production.