How to Flatten Optionals into a Stream in Java

Java 8's Optional Usage with Stream::flatMap

Stream::flatMap is a powerful tool in Java 8 for combining multiple streams into a single stream. However, it requires returning a stream, which can be problematic when dealing with Optionals.

Problem

Consider a situation where we have a List and a method that maps each Thing to an Optional. We want to map the Things to Optionals, and then retrieve the first non-empty Optional.

A naive approach using Stream::flatMap and Optional::findFirst would fail, as Optionals do not provide a stream() method:

<code class="java">things.stream().flatMap(this::resolve).findFirst(); // Error!</code>

Solution

Java 16 and Later

Java 16 introduced Stream.mapMulti, which allows mapping an Optional to a stream of its non-empty elements:

<code class="java">Optional<Other> result =
    things.stream()
          .map(this::resolve)
          .<Other>mapMulti(Optional::ifPresent)
          .findFirst();</code>

Java 9

Java 9 added Optional.stream, which directly returns a stream of the non-empty Optional value:

<code class="java">Optional<Other> result =
    things.stream()
          .map(this::resolve)
          .flatMap(Optional::stream)
          .findFirst();</code>

Java 8

For Java 8, we can use a helper function to convert an Optional to a stream:

<code class="java">static <T> Stream<T> streamopt(Optional<T> opt) {
    if (opt.isPresent())
        return Stream.of(opt.get());
    else
        return Stream.empty();
}</code>

Using this helper function, the solution becomes:

<code class="java">Optional<Other> result =
    things.stream()
          .flatMap(t -> streamopt(resolve(t)))
          .findFirst();</code>

The above is the detailed content of How to Flatten Optionals into a Stream in Java. For more information, please follow other related articles on the PHP Chinese website!