有没有更清晰的方法来处理短期期权？

Question

我喜欢Java中的可选。在一个简单的类中，它允许我清楚地识别返回类型和参数，这些类型和参数可能可用，也可能不可用。

我要解决的一件事是，必须将其分配给一个短期变量，然后将其继承到后续的每个范围中。

当使用这样的选项时，我喜欢使用简单的变量名称opts：

   Optional<ThingA> opt = maybeGetThing();

   if (opt.isPresent()) {
      ThingA usefulVariableName = opt.get();
      ...

但当我需要在这个范围内使用变量名时。。。

void method() {
   Optional<ThingA> opt = maybeGetThing();

   if (opt.isPresent()) {
      ThingA usefulVariableName = opt.get();

      usefulVariableName.doA();
      usefulVariableName.doB();
      usefulVariableName.doC();

      // Duplicate local variable opt
      Optional<ThingB> opt = usefulVariableName.maybeAnotherThing();
   }
}

我可以使用诸如optA和optB之类的东西。但是我想知道是否有另一种方法可以编写这段代码，而不必枚举我的临时变量。这有点像懒惰的变量名，比如aaaaaaaaaabbb或其他东西。

我不想像这样明确地命名我所有的选项：

   Optional<ThingA> optUsefulVariableName = maybeGetThing();

   if (optUsefulVariableName.isPresent()) {
      ThingA usefulVariableName = optUsefulVariableName.get();
      ...

虽然准确，但却极其冗长。我还尝试使用像opt和I这样的一次性名称，以表明这些名称实际上只是暂时的，不应超出其直接范围（即使它们将被继承）。

更新：

我已经看到了使用ifPresent（）的建议，但我不知道如何在可选项为空时也需要执行操作的情况下使用它：

void method() {
   Optional<ThingA> opt = maybeGetThing();

   if (!opt.isPresent()) {
      doSomethingOnlyHere();

      return;
   }

   if (opt.isPresent()) {
      ThingA usefulVariableName = opt.get();

      usefulVariableName.doA();
      usefulVariableName.doB();
      usefulVariableName.doC();

      // Duplicate local variable opt
      Optional<ThingB> opt = usefulVariableName.maybeAnotherThing();
   }
}

当我尝试使用ifPresent（）进行重构时：

void method() {
   // Doesn't handle instance where I need side effects on an empty optional
   maybeGetThing().ifPresent(usefulVariableName -> {
      ...
   }
}

Answer 1

从Java9开始

void method() {
   maybeGetThing().ifPresentOrElse(
           usefulVariableName -> {
               usefulVariableName.doA();
               usefulVariableName.doB();
               usefulVariableName.doC();

               // No duplicate local variable opt
               Optional<ThingB> opt = usefulVariableName.maybeAnotherThing();
           },
           this::doSomethingOnlyHere
   );
}

我的经验是，你很少需要或想要使用isPresent和/或get，它们是低级的。对于基本的东西，ifPresent（带f）和ifPresetnOrElse都可以。其他人则认为map和flatMap也非常有用。

Answer 2

消除变量和调用Optional#get的最基本方法是使用Optional。ifPresent，如果可选项有值，则调用函数。

maybeGetThing().ifPresent(val -> {
    // do stuff with side effects here
});

使用Optional仍然是一种非常有限的方式，因为Optional的主要目的之一是促进函数式编程。如果你是个初学者，这可能会让你有点不知所措，但我们的想法是让函数返回一些东西，而不是依赖于副作用的函数。依赖于副作用的功能无法链接在一起，通常更难推理。

从技术上讲，Optional是一种叫做函子的东西（来自范畴论）。它是一个围绕一个值（无论T是什么）的包装器，它允许通过一系列操作传递该值，对其进行操作，并将其传递给下一个操作，直到我们得到我们想要的，然后操作链以一个终端（即最终）操作结束。如果存在，终端操作可能会返回未包装的值；如果不存在，终端操作可能会抛出或返回一些默认值。

对于可选，如果值不存在，它将跳过任何后续操作。

有一些常见的操作，比如map、filter、flatMap（好的，这是一个Monad操作）和其他更具体的java操作，比如Optional#orElse和Optional#orelsetrow。

要重构示例代码，可以这样做。

void method() {
   return maybeGetThing().flatMap(val -> {

       // eek side effects
       val.doA();
       val.doB();
       val.doC();

       return val.maybeAnotherThing();
   });  
}

flatMap是一种将一种可选类型转换为另一种可选类型的方法。如果返回值不是可选的，则使用map。

您可以看到，我们已经不再需要返回值的名称，而是支持命名lambda函数的参数。lambda函数具有作用域，因此如果需要的话，可以重用这些名称。

我通常喜欢提供可运行的代码，所以这里有一个我所说的可运行的人为例子。

import java.util.Optional;

class DummyClass {

    private int val = 0;

    public void doA(){ val += 1; }

    public void doB(){ val += 2; }

    public void doC(){ val += 3; }

    public Optional<String> maybeAnotherThing(){
        return Optional.of(Integer.toString(val));
    }
}

public class UseOptional5 {   

    Optional<DummyClass> maybeGetThing(){
        return Optional.of(new DummyClass());
    }

    String method() {
        return maybeGetThing()
               // you can put other operations here
               .flatMap(val -> {

                    // eek side effects
                    val.doA();
                    val.doB();
                    val.doC();

                    return val.maybeAnotherThing();
                })
                // you can put other operations here too
                .orElseThrow(() -> new IllegalArgumentException("fail!!"));
    }    

    public static void main(String args[]) {

        UseOptional5 x = new UseOptional5();

        System.out.println(x.method());
    }
}