组合选项最优雅的方式是什么？

Question

这是我目前所得到的：

Optional<Foo> firstChoice = firstChoice();
Optional<Foo> secondChoice = secondChoice();
return Optional.ofNullable(firstChoice.orElse(secondChoice.orElse(null)));

这让我觉得既可怕又浪费。如果 firstChoice 存在，我会不必要地计算 secondChoice。

还有一个更高效的版本：

Optional<Foo> firstChoice = firstChoice();
if(firstChoice.isPresent()) {
 return firstChoice;
} else {
 return secondChoice();
}

在这里，如果不复制映射器或声明另一个局部变量，我就无法将某些映射函数链接到末尾。所有这些都使得代码比要解决的实际问题更复杂。

我宁愿写这个：

return firstChoice().alternatively(secondChoice());

但是 Optional::alternatively 显然不存在。现在呢？

Answer 1

试试这个：

firstChoice().map(Optional::of)
             .orElseGet(this::secondChoice);

map 方法为您提供Optional<Optional<Foo>>。然后，orElseGet 方法将其变平为Optional<Foo>。 secondChoice 方法只有在 firstChoice() 返回空的可选项时才会被计算。

Answer 2

可能是这样的：

Optional<String> finalChoice = Optional.ofNullable(firstChoice()
    .orElseGet(() -> secondChoice()
    .orElseGet(() -> null)));

发件人：Chaining Optionals in Java 8

Answer 3

您可以简单地将其替换为，

Optional<Foo> firstChoice = firstChoice();
return firstChoice.isPresent()? firstChoice : secondChoice();

除非 firstChoice.isPresent() 为 false，否则上述代码不会调用。

但是您必须准备好调用这两个函数以获得所需的输出。没有其他方法可以逃避检查。

• 最好的情况是首选返回 true。
• 最坏的情况是首选返回 false，因此另一种方法 呼吁第二选择。

Answer 4

这是@marstran 解决方案对于任意数量的选项的概括：

@SafeVarargs
public static <T> Optional<T> selectOptional(Supplier<Optional<T>>... optionals) {
    return Arrays.stream(optionals)
            .reduce((s1, s2) -> () -> s1.get().map(Optional::of).orElseGet(s2))
            .orElse(Optional::empty).get();
}

测试：

public static Optional<String> first() {
    System.out.println("foo called");
    return Optional.empty();
}

public static Optional<String> second() {
    System.out.println("bar called");
    return Optional.of("bar");
}

public static Optional<String> third() {
    System.out.println("baz called");
    return Optional.of("baz");
}

public static void main(String[] args) {
    System.out.println(selectOptional(() -> first(), () -> second(), () -> third()));
}

输出：

foo called
bar called
Optional[bar]

Answer 5

Java 8 不支持这一点让我感到非常沮丧，因此我切换回了具有 or 的 guava 选项：

public abstract Optional<T> or(Optional<? extends T> secondChoice)

如果存在值，则返回此 Optional；否则选择第二个。

Answer 6

惰性计算和任意数量的Optional 元素

Stream.<Supplier<Optional<Foo>>>of(
        this::firstChoice,
        this::secondChoice
).map(
        Supplier::get
).filter(
        Optional::isPresent
).findFirst(
).orElseGet(
    Optional::empty
);

Answer 7

Java 9 针对这种情况添加了Optional.or​(Supplier<? extends Optional<? extends T>> supplier) 方法。

给定方法firstChoice() 和secondChoice()，每个都返回Optional<Foo>，下面的单行代码使用Optional.or 来达到预期的结果：

return firstChoice().or(this::secondChoice);

这种方法的额外好处是，当firstChoice 为空时，只计算secondChoice。

Answer 8

这是一种适用于基于流 API 的任意数量的Optional 的方法：

return Arrays.asList(firstChoice, secondChoice).stream()
  .filter(Optional::isPresent)
  .map(Optional::get)
  .findFirst().orElse(null);

这不是最短的。但更通俗易懂。

如果您已经在使用其中一个库，另一种方法是使用来自 commons-lang 的 Guava 的 firstNonNull()：

firstNonNull(firstChoice.orElse(null), secondChoice.orElse(null));