Java中的可选orElse可选

我一直在使用Java 8中的新Optional类型，并且遇到了似乎不受功能支持的常见操作：“ orElseOptional”

考虑以下模式：

Optional<Result> resultFromServiceA = serviceA(args);
if (resultFromServiceA.isPresent) return result;
else {
    Optional<Result> resultFromServiceB = serviceB(args);
    if (resultFromServiceB.isPresent) return resultFromServiceB;
    else return serviceC(args);
}

这种模式有多种形式，但是归结为希望在一个可选函数上使用一个“ orElse”，该函数需要一个函数来生成一个新的可选变量，只有当当前的不存在该函数时才调用它。

它的实现如下所示：

public Optional<T> orElse(Supplier<Optional<? extends T>> otherSupplier) {
    return value != null ? this : other.get();
}

我很好奇是否有这种方法不存在的原因，是否以一种意想不到的方式使用Optional，以及人们想出了什么其他方式来处理这种情况。

我应该说，我认为涉及定制实用程序类/方法的解决方案并不优雅，因为使用我的代码的人不一定知道它们的存在。

另外，如果有人知道，这种方法是否会包含在JDK 9中，我可以在哪里提出这种方法？对我来说，这似乎是对API的明显忽略。

这是JDK 9的一部分，形式为or，其中包含Supplier<Optional<T>>。您的示例将是：

return serviceA(args)
    .or(() -> serviceB(args))
    .or(() -> serviceC(args));

有关详细信息，请参阅Javadoc或我写的这篇文章。

根据当前的API，最干净的“试用服务”方法是：

Optional<Result> o = Stream.<Supplier<Optional<Result>>>of(
    ()->serviceA(args), 
    ()->serviceB(args), 
    ()->serviceC(args), 
    ()->serviceD(args))
.map(Supplier::get)
.filter(Optional::isPresent)
.map(Optional::get)
.findFirst();

重要的方面不是您必须编写一次（连续）的操作链，而是添加另一个服务（或修改服务列表）很容易。在这里，添加或删除单个()->serviceX(args)就足够了。

由于流的延迟评估，如果先前的服务返回了non-empty，则不会调用任何服务Optional。

它不是很漂亮，但是可以正常工作：

return serviceA(args)
  .map(Optional::of).orElseGet(() -> serviceB(args))
  .map(Optional::of).orElseGet(() -> serviceC(args))
  .map(Optional::of).orElseGet(() -> serviceD(args));

.map(func).orElseGet(sup)是与一起使用的非常方便的模式Optional。意思是“如果这Optional包含价值v，请给我func(v)，否则给我sup.get()”。

在这种情况下，我们调用serviceA(args)并得到一个Optional<Result>。如果其中Optional包含值v，那么我们想要获取Optional.of(v)，但是如果它为空，则我们想要获取serviceB(args)。重复冲洗，有更多选择。

此模式的其他用途是

• .map(Stream::of).orElseGet(Stream::empty)
• .map(Collections::singleton).orElseGet(Collections::emptySet)

也许这就是您所追求的：从一个可选项目或另一个可选项目中获取价值

否则，您可能需要看看Optional.orElseGet。这是我认为您追求的示例：

result = Optional.ofNullable(serviceA().orElseGet(
                                 () -> serviceB().orElseGet(
                                     () -> serviceC().orElse(null))));

假设您仍在使用JDK8，有几种选择。

选项1：制作自己的帮助器方法

例如：

public class Optionals {
    static <T> Optional<T> or(Supplier<Optional<T>>... optionals) {
        return Arrays.stream(optionals)
                .map(Supplier::get)
                .filter(Optional::isPresent)
                .findFirst()
                .orElseGet(Optional::empty);
    }
}

这样您就可以：

return Optionals.or(
   ()-> serviceA(args),
   ()-> serviceB(args),
   ()-> serviceC(args),
   ()-> serviceD(args)
);

选项＃2：使用库

例如，谷歌番石榴的Optional支持适当的or()操作（就像JDK9一样），例如：

return serviceA(args)
  .or(() -> serviceB(args))
  .or(() -> serviceC(args))
  .or(() -> serviceD(args));

（每个服务都返回com.google.common.base.Optional，而不是java.util.Optional）。

这看起来很适合模式匹配，并且具有Some and None实现（例如Javaslang和FunctionalJava中的实现）或cyclops -react中的惰性Maybe实现，这是更传统的Option接口。。我是该库的作者。

使用cyclops-react，您还可以在JDK类型上使用结构模式匹配。对于Optional，您可以通过访客模式匹配当前和缺席案例。它看起来像这样-

  import static com.aol.cyclops.Matchables.optional;

  optional(serviceA(args)).visit(some -> some , 
                                 () -> optional(serviceB(args)).visit(some -> some,
                                                                      () -> serviceC(args)));