将 Java 8 的 Optional 与 Stream::flatMap 一起使用

Question

新的 Java 8 流框架和朋友们制作了一些非常简洁的 Java 代码，但我遇到了一个看似简单但很难做到简洁的情况。

考虑一个List<Thing> things和方法Optional<Other> resolve(Thing thing) 。 我想将Thing映射到Optional<Other>并获得第一个Other 。

显而易见的解决方案是使用things.stream().flatMap(this::resolve).findFirst() ，但flatMap要求您返回一个流，而Optional没有stream()方法（或者它是Collection或提供将其转换为 Collection 或将其视为Collection的方法）。

我能想到的最好的是：

things.stream()
    .map(this::resolve)
    .filter(Optional::isPresent)
    .map(Optional::get)
    .findFirst();

但对于一个非常常见的情况来说，这似乎是非常冗长的。

有人有更好的主意吗？

Answer 1

爪哇 9

Optional.stream已添加到 JDK 9。这使您能够执行以下操作，而无需任何辅助方法：

Optional<Other> result =
    things.stream()
          .map(this::resolve)
          .flatMap(Optional::stream)
          .findFirst();

爪哇 8

是的，这是 API 中的一个小漏洞，因为将Optional<T>转换为长度为零或一的Stream<T>有点不方便。 你可以这样做：

Optional<Other> result =
    things.stream()
          .map(this::resolve)
          .flatMap(o -> o.isPresent() ? Stream.of(o.get()) : Stream.empty())
          .findFirst();

但是，在flatMap中使用三元运算符有点麻烦，因此最好编写一个小辅助函数来执行此操作：

/**
 * Turns an Optional<T> into a Stream<T> of length zero or one depending upon
 * whether a value is present.
 */
static <T> Stream<T> streamopt(Optional<T> opt) {
    if (opt.isPresent())
        return Stream.of(opt.get());
    else
        return Stream.empty();
}

Optional<Other> result =
    things.stream()
          .flatMap(t -> streamopt(resolve(t)))
          .findFirst();

在这里，我内联了对resolve()的调用，而不是单独的map()操作，但这是个人喜好问题。

Answer 2

我根据用户srborlongan提出的编辑将第二个答案添加到我的另一个答案中。 我认为提出的技术很有趣，但它并不适合作为我的答案的编辑。 其他人同意，提议的编辑被否决。 （我不是选民之一。）不过，这项技术有其优点。 如果 srborlongan 发布了他/她自己的答案，那将是最好的。 这还没有发生，我不希望这项技术在 StackOverflow 拒绝编辑历史的迷雾中消失，所以我决定自己将它作为一个单独的答案浮出水面。

基本上，该技术是以一种巧妙的方式使用一些Optional方法，以避免必须使用三元运算符 ( ? : :) 或 if/else 语句。

我的内联示例将以这种方式重写：

Optional<Other> result =
    things.stream()
          .map(this::resolve)
          .flatMap(o -> o.map(Stream::of).orElseGet(Stream::empty))
          .findFirst();

我使用辅助方法的示例将以这种方式重写：

/**
 * Turns an Optional<T> into a Stream<T> of length zero or one depending upon
 * whether a value is present.
 */
static <T> Stream<T> streamopt(Optional<T> opt) {
    return opt.map(Stream::of)
              .orElseGet(Stream::empty);
}

Optional<Other> result =
    things.stream()
          .flatMap(t -> streamopt(resolve(t)))
          .findFirst();

评论

让我们直接比较原始版本和修改版本：

// original
.flatMap(o -> o.isPresent() ? Stream.of(o.get()) : Stream.empty())

// modified
.flatMap(o -> o.map(Stream::of).orElseGet(Stream::empty))

原始方法是一种简单的方法：我们得到一个Optional<Other> ； 如果它有值，我们返回一个包含该值的流，如果它没有值，我们返回一个空流。 很简单，很容易解释。

修改很聪明，并且具有避免条件的优点。 （我知道有些人不喜欢三元运算符。如果滥用它确实会使代码难以理解。）但是，有时事情可能太聪明了。 修改后的代码也以Optional<Other>开始。 然后它调用Optional.map定义如下：

如果存在值，则对其应用提供的映射函数，如果结果为非 null，则返回描述结果的 Optional。 否则返回一个空的 Optional。

map(Stream::of)调用返回Optional<Stream<Other>> 。 如果输入 Optional 中存在值，则返回的 Optional 包含一个包含单个 Other 结果的 Stream。 但如果该值不存在，则结果为空 Optional。

接下来，对orElseGet(Stream::empty)的调用返回Stream<Other>类型的值。 如果它的输入值存在，它会获取该值，即单元素Stream<Other> 。 否则（如果输入值不存在）它返回一个空的Stream<Other> 。 所以结果是正确的，和原来的条件码一样。

在讨论我的回答的评论中，关于被拒绝的编辑，我将这种技术描述为“更简洁但也更模糊”。 我坚持这一点。 我花了一段时间才弄清楚它在做什么，我也花了一些时间来写下上面对它在做什么的描述。 关键的微妙之处在于从Optional<Other>到Optional<Stream<Other>>的转换。 一旦你明白这一点，这是有道理的，但对我来说并不明显。

不过，我承认，最初晦涩难懂的事物随着时间的推移可能会变得惯用语。 可能这种技术最终成为实践中的最佳方式，至少在添加Optional.stream之前（如果有的话）。

更新： Optional.stream已添加到 JDK 9。

Answer 3

你不能像你已经在做的那样更简洁。

您声称您不想要.filter(Optional::isPresent)和.map(Optional::get) 。

这已通过@StuartMarks 描述的方法解决，但是结果您现在将其映射到Optional<T> ，所以现在您需要使用.flatMap(this::streamopt)和最后的get() 。

所以它仍然包含两个语句，您现在可以使用新方法获取异常！ 因为，如果每个可选项都是空的怎么办？ 然后findFirst()将返回一个空的可选项，而您的get()将失败！

所以你有什么：

things.stream()
    .map(this::resolve)
    .filter(Optional::isPresent)
    .map(Optional::get)
    .findFirst();

实际上是完成您想要的最佳方式，那就是您要将结果保存为T ，而不是Optional<T> 。

我冒昧地创建了一个CustomOptional<T>类，该类包装了Optional<T>并提供了一个额外的方法flatStream() 。 请注意，您不能扩展Optional<T> ：

class CustomOptional<T> {
    private final Optional<T> optional;

    private CustomOptional() {
        this.optional = Optional.empty();
    }

    private CustomOptional(final T value) {
        this.optional = Optional.of(value);
    }

    private CustomOptional(final Optional<T> optional) {
        this.optional = optional;
    }

    public Optional<T> getOptional() {
        return optional;
    }

    public static <T> CustomOptional<T> empty() {
        return new CustomOptional<>();
    }

    public static <T> CustomOptional<T> of(final T value) {
        return new CustomOptional<>(value);
    }

    public static <T> CustomOptional<T> ofNullable(final T value) {
        return (value == null) ? empty() : of(value);
    }

    public T get() {
        return optional.get();
    }

    public boolean isPresent() {
        return optional.isPresent();
    }

    public void ifPresent(final Consumer<? super T> consumer) {
        optional.ifPresent(consumer);
    }

    public CustomOptional<T> filter(final Predicate<? super T> predicate) {
        return new CustomOptional<>(optional.filter(predicate));
    }

    public <U> CustomOptional<U> map(final Function<? super T, ? extends U> mapper) {
        return new CustomOptional<>(optional.map(mapper));
    }

    public <U> CustomOptional<U> flatMap(final Function<? super T, ? extends CustomOptional<U>> mapper) {
        return new CustomOptional<>(optional.flatMap(mapper.andThen(cu -> cu.getOptional())));
    }

    public T orElse(final T other) {
        return optional.orElse(other);
    }

    public T orElseGet(final Supplier<? extends T> other) {
        return optional.orElseGet(other);
    }

    public <X extends Throwable> T orElseThrow(final Supplier<? extends X> exceptionSuppier) throws X {
        return optional.orElseThrow(exceptionSuppier);
    }

    public Stream<T> flatStream() {
        if (!optional.isPresent()) {
            return Stream.empty();
        }
        return Stream.of(get());
    }

    public T getTOrNull() {
        if (!optional.isPresent()) {
            return null;
        }
        return get();
    }

    @Override
    public boolean equals(final Object obj) {
        return optional.equals(obj);
    }

    @Override
    public int hashCode() {
        return optional.hashCode();
    }

    @Override
    public String toString() {
        return optional.toString();
    }
}

你会看到我添加了flatStream() ，如下所示：

public Stream<T> flatStream() {
    if (!optional.isPresent()) {
        return Stream.empty();
    }
    return Stream.of(get());
}

用作：

String result = Stream.of("a", "b", "c", "de", "fg", "hij")
        .map(this::resolve)
        .flatMap(CustomOptional::flatStream)
        .findFirst()
        .get();

您仍然需要在此处返回Stream<T> ，因为您不能返回T ，因为如果!optional.isPresent() ，则T == null如果您声明它，那么您的.flatMap(CustomOptional::flatStream)会尝试将null添加到流中，这是不可能的。

例如：

public T getTOrNull() {
    if (!optional.isPresent()) {
        return null;
    }
    return get();
}

用作：

String result = Stream.of("a", "b", "c", "de", "fg", "hij")
        .map(this::resolve)
        .map(CustomOptional::getTOrNull)
        .findFirst()
        .get();

现在将在流操作中抛出NullPointerException 。

结论

你用的方法，其实是最好的方法。

Answer 4

使用reduce的稍短版本：

things.stream()
  .map(this::resolve)
  .reduce(Optional.empty(), (a, b) -> a.isPresent() ? a : b );

您还可以将 reduce 函数移动到静态实用程序方法，然后它变为：

  .reduce(Optional.empty(), Util::firstPresent );

Answer 5

由于我之前的答案似乎不太受欢迎，我将再试一次。

一个简短的回答：

你大多是在正确的轨道上。 我能想出的获得所需输出的最短代码是：

things.stream()
      .map(this::resolve)
      .filter(Optional::isPresent)
      .findFirst()
      .flatMap( Function.identity() );

这将满足您的所有要求：

1. 它将找到解析为非空Optional<Result>的第一个响应
2. 它根据需要懒惰地调用this::resolve
3. this::resolve在第一个非空结果后不会被调用
4. 它将返回Optional<Result>

更长的答案

与 OP 初始版本相比，唯一的修改是我在调用.findFirst() ) 之前删除了.map(Optional::get)并添加了.flatMap(o -> o)作为链中的最后一个调用。

每当流找到实际结果时，这对摆脱双重可选具有很好的效果。

在 Java 中，你真的不能比这更短。

使用更传统for循环技术的替代代码片段将具有大约相同数量的代码行，并且具有或多或少相同的顺序和您需要执行的操作数量：

1. 调用this.resolve ，
2. 基于Optional.isPresent的过滤
3. 返回结果和
4. 处理负面结果的某种方式（当什么都没有找到时）

为了证明我的解决方案像宣传的那样有效，我编写了一个小测试程序：

public class StackOverflow {

    public static void main( String... args ) {
        try {
            final int integer = Stream.of( args )
                    .peek( s -> System.out.println( "Looking at " + s ) )
                    .map( StackOverflow::resolve )
                    .filter( Optional::isPresent )
                    .findFirst()
                    .flatMap( o -> o )
                    .orElseThrow( NoSuchElementException::new )
                    .intValue();

            System.out.println( "First integer found is " + integer );
        }
        catch ( NoSuchElementException e ) {
            System.out.println( "No integers provided!" );
        }
    }

    private static Optional<Integer> resolve( String string ) {
        try {
            return Optional.of( Integer.valueOf( string ) );
        }
        catch ( NumberFormatException e )
        {
            System.out.println( '"' + string + '"' + " is not an integer");
            return Optional.empty();
        }
    }

}

（它确实有一些额外的行用于调试和验证只有尽可能多的调用来解决需要...）

在命令行上执行此操作，我得到以下结果：

$ java StackOferflow a b 3 c 4
Looking at a
"a" is not an integer
Looking at b
"b" is not an integer
Looking at 3
First integer found is 3

Answer 6

派对迟到了，但是怎么样

things.stream()
    .map(this::resolve)
    .filter(Optional::isPresent)
    .findFirst().get();

如果您创建一个 util 方法来手动将可选转换为流，则可以摆脱最后一个 get() ：

things.stream()
    .map(this::resolve)
    .flatMap(Util::optionalToStream)
    .findFirst();

如果您立即从您的解析函数返回流，您可以多保存一行。

Answer 7

我想推广为功能 API 创建助手的工厂方法：

Optional<R> result = things.stream()
        .flatMap(streamopt(this::resolve))
        .findFirst();

工厂方法：

<T, R> Function<T, Stream<R>> streamopt(Function<T, Optional<R>> f) {
    return f.andThen(Optional::stream); // or the J8 alternative:
    // return t -> f.apply(t).map(Stream::of).orElseGet(Stream::empty);
}

推理：

• 与一般的方法引用一样，与 lambda 表达式相比，您不会意外地从可访问范围捕获变量，例如：

  t -> streamopt(resolve(o))

• 它是可组合的，您可以例如在工厂方法结果上调用Function::andThen ：

  streamopt(this::resolve).andThen(...)

  而在 lambda 的情况下，您需要先转换它：

  ((Function<T, Stream<R>>) t -> streamopt(resolve(t))).andThen(...)

Answer 8

如果您坚持使用 Java 8，但可以访问 Guava 21.0 或更高版本，则可以使用Streams.stream将可选项转换为流。

因此，给定

import com.google.common.collect.Streams;

你可以写

Optional<Other> result =
    things.stream()
        .map(this::resolve)
        .flatMap(Streams::stream)
        .findFirst();

Answer 9

如果您不介意使用第三方库，您可以使用Javaslang 。 它类似于 Scala，但用 Java 实现。

它带有一个完整的不可变集合库，与 Scala 中的集合库非常相似。 这些集合取代了 Java 的集合和 Java 8 的 Stream。 它也有自己的 Option 实现。

import javaslang.collection.Stream;
import javaslang.control.Option;

Stream<Option<String>> options = Stream.of(Option.some("foo"), Option.none(), Option.some("bar"));

// = Stream("foo", "bar")
Stream<String> strings = options.flatMap(o -> o);

这是初始问题示例的解决方案：

import javaslang.collection.Stream;
import javaslang.control.Option;

public class Test {

    void run() {

        // = Stream(Thing(1), Thing(2), Thing(3))
        Stream<Thing> things = Stream.of(new Thing(1), new Thing(2), new Thing(3));

        // = Some(Other(2))
        Option<Other> others = things.flatMap(this::resolve).headOption();
    }

    Option<Other> resolve(Thing thing) {
        Other other = (thing.i % 2 == 0) ? new Other(i + "") : null;
        return Option.of(other);
    }

}

class Thing {
    final int i;
    Thing(int i) { this.i = i; }
    public String toString() { return "Thing(" + i + ")"; }
}

class Other {
    final String s;
    Other(String s) { this.s = s; }
    public String toString() { return "Other(" + s + ")"; }
}

免责声明：我是 Javaslang 的创建者。

Answer 10

Null 由提供的 Stream 支持 My library AbacusUtil 。 这是代码：

Stream.of(things).map(e -> resolve(e).orNull()).skipNull().first();

Answer 11

那个怎么样？

private static List<String> extractString(List<Optional<String>> list) {
    List<String> result = new ArrayList<>();
    list.forEach(element -> element.ifPresent(result::add));
    return result;
}

https://stackoverflow.com/a/58281000/3477539

Answer 12

很可能你做错了。

Java 8 Optional 并不意味着以这种方式使用。 它通常只保留用于可能返回值或不返回值的终端流操作，例如 find。

在您的情况下，最好先尝试找到一种廉价的方法来过滤掉那些可解析的项目，然后将第一个项目作为可选项目并将其作为最后一个操作来解决。 更好的是 - 不是过滤，而是找到第一个可解析的项目并解决它。

things.filter(Thing::isResolvable)
      .findFirst()
      .flatMap(this::resolve)
      .get();

经验法则是，您应该努力减少流中的项目数量，然后再将它们转换为其他内容。 当然是 YMMV。