新的Java 8流框架及其朋友可以编写一些非常简洁的Java代码，但我遇到过一个看似简单的情况，但要做到简洁却很棘手。
考虑一个列表<Thing> things and method Optional<Other> resolve(Thing Thing)。我想映射的东西可选<其他>s，并获得第一个其他。
显而易见的解决方案是使用things.stream().flatMap(this::resolve). findfirst()，但flatMap要求您返回一个流，而Optional没有stream()方法(或者它是一个集合或提供一个方法将其转换为或将其视为一个集合)。
我能想到的最好的是:
things.stream()
.map(this::resolve)
.filter(Optional::isPresent)
.map(Optional::get)
.findFirst();
但对于一个很普通的例子来说，这似乎太啰嗦了。
有人有更好的主意吗?
当前回答
那个怎么样?
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
其他回答
我想推广用于为函数式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(…)
使用reduce的略短版本:
things.stream()
.map(this::resolve)
.reduce(Optional.empty(), (a, b) -> a.isPresent() ? a : b );
你也可以将reduce函数移动到一个静态实用程序方法，然后它变成:
.reduce(Optional.empty(), Util::firstPresent );
流提供的我的库abacus-common支持Null。下面是代码:
Stream.of(things).map(e -> resolve(e).orNull()).skipNull().first();
很可能你做错了。
Java 8 Optional不是这样使用的。它通常只保留给终端流操作，这些操作可能返回值，也可能不返回值，例如find。
在您的情况下，最好先尝试找到一种廉价的方法来过滤那些可解析的项，然后将第一个项作为可选项，并将其作为最后一个操作进行解析。更好的方法是，找到第一个可解决的项目并解决它，而不是过滤。
things.filter(Thing::isResolvable)
.findFirst()
.flatMap(this::resolve)
.get();
经验法则是，在将流中的项转换为其他内容之前，应该努力减少它们的数量。当然是YMMV。
如果你不介意使用第三方库，你可以使用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的创造者。