在Stream :: flatMap中使用Java 8的Optional

Question

新的Java 8流框架和朋友们制作了一些非常简洁的Java代码,但是我遇到了一个看似简单的情况,简单易懂.

考虑一个List<Thing> things方法Optional<Other> resolve(Thing thing).我想将Things 映射到Optional<Other>s并获得第一个Other.显而易见的解决方案是使用things.stream().flatMap(this::resolve).findFirst(),但flatMap要求您返回一个流,并且Optional没有stream()方法(或者它是Collection一个方法或提供将其转换为或以其方式查看的方法Collection).

我能想到的最好的是:

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

但这似乎是一个非常普遍的案例,似乎非常冗长.谁有更好的主意？

Answer 1

Java 9

Optional.stream 已添加到JDK 9.这使您可以执行以下操作,而无需任何帮助方法:

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

Java 8

是的,这是API中的一个小漏洞,因为将Optional变为零或一个长度的流有点不方便.你可以这样做:

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.但是如果该值不存在,则结果为空可选.

接下来,调用orElseGet(Stream::empty)返回一个type类型的值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)和a 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初始版本相比，唯一的修改是我.map(Optional::get)在调用之前删除了该链接，.findFirst()并将其添加.flatMap(o -> o)为链中的最后一个调用。

每当流发现实际结果时，这样做都具有摆脱double-Optional的良好效果。

在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(...)