Add a side-effect to Java Stream after each element is consumed?

This is a simplified example but it illustrates the point.

Let's say I have a method defined like this:

Stream<String> generateStream() {
  return Stream.of("hello", "world"); // (S)
}

Is there a way to make S for example print something <i>after</i> an element has been consumed without the consumer of the stream having to do or know anything about it?

For example, I'd to modify S so that this:

generateStream().forEach(System.out::println)

actually prints out this to the console:

hello
consumed
world
consumed

Is this possible in Java 8 and if so how?

You can use flatMap with a close action:

Stream<String> generateStream() {
  return Stream.of("hello", "world")
      .flatMap(s -> Stream.of(s).onClose(() -> System.out.println(s+" consumed")));
}

which works as intended:

generateStream().forEach(System.out::println);

hello
hello consumed
world
world consumed

even for short-circuiting operations:

Optional<String> o = generateStream().filter(s -> s.startsWith("he")).findFirst();
o.ifPresent(s -> System.out.println("found "+s));

hello consumed
found hello

But note that this can have a dramatic impact on the performance, compared to an operation without flatMap. But for debugging purposes, or for cases where performance doesn’t matter, it might be helpful.

Further, keep in mind that being consumed by the Stream pipeline doesn’t imply that the terminal operation won’t keep a reference to it nor stop accessing it.

It works that way for the forEach operation, but e.g., for reduce((a,b) -> a), all elements get consumed one after the other, but a reference to the first element will be kept until the end and even returned as final result. For min​(comparator), any element might be held until a smaller one has been encountered. And finally, operations like toArray() hold and return all elements in the result.

Also, stateful operations may detach the subsequent pipeline processing from the source stream. E.g. a sorted step may act like a toArray, buffering all elements making them appear as consumed to the source, before sorting the array and continuing by streaming over the array. Likewise, distinct will hold references to objects beyond their consumption and in a parallel stream, their subsequent processing might be deferred to a point after closing the source stream.

you can use peek in your chain to consume an element and return a Stream.
forEach is closing the stream

    Stream.of("hello", "world")
        .peek(System.out::println)
        .forEach(word -> System.out.println("consumed")); 

or you can chain consumers in foreach to have your expected behaviour.
Stream doesn't have an explicit method in the api for what you are asking,
you can chain methods using peek instead of foreach to not finish the stream, or chain consumer in foreach

    Consumer<String> stringConsumer = System.out::println;
    Consumer<String> endConsumed = string -> System.out.println("consumed");
    Stream.of("hello", "world")
            .forEach(stringConsumer.andThen(endConsumed));