来晚了，但是

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

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

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

如果你从resolve函数中立即返回stream，你就多保存一行。

如果你只能使用Java 8，但可以访问Guava 21.0或更新版本，你可以使用Streams。流将可选项转换为流。

因此,鉴于

import com.google.common.collect.Streams;

你可以写

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

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

它带有一个完整的不可变集合库，与Scala中的集合库非常相似。这些集合取代了Java的集合和Java 8的流。它也有自己的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的创造者。

流提供的我的库abacus-common支持Null。下面是代码:

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

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

简短的回答:

你基本上是在正确的轨道上。得到你想要的输出的最短代码是这样的:

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

这将符合您的所有要求:

它将找到解析为非空可选<Result>的第一个响应 它会根据需要惰性地调用::resolve 这个::resolve不会在第一个非空结果之后被调用 它将返回Optional<Result>

再回答

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

当流找到一个实际的结果时，这有一个很好的效果，可以消除double-Optional。

在Java中没有比这个更短的了。

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

调用this.resolve, 基于Optional.isPresent进行过滤 返回结果和 处理消极结果的方法(当什么都没有发现时)

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

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

我想推广用于为函数式api创建helper的工厂方法:

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::and然后在工厂方法result上: streamopt(::解决).andThen(…) 而在lambda的情况下，你需要先强制转换: ((T <函数,流< R > >) T - > streamopt(解决(T))) .andThen(…)