《Java常见问题解法》第六章 Optional类

Java常见问题的简单解法

提示：总结于LeetCode书籍《Java常见问题的简单解法》，全书其实就是用Stream去通过函数式编程，更加简洁，快速，高效的解决实际问题。

---

---

第六章 Optional类

---

一、Optional的创建

Optional实例是不可变的，但是他包装的对象却不一定是不可变的。如果创建一个包含可变对象实例的Optional，则仍然可以对实例进行修改。

AtomicInteger counter = new AtomicInteger();
Optional<AtomicInteger> opt = Optional.ofNullable(counter);


System.out.println(optional);                        // Optional[0]

//直接使用计数器自增　
counter.incrementAndGet();                           
System.out.println(optional);                        // Optional[1]
　
//检索包含的值并自增　
optional.get().incrementAndGet();                    
System.out.println(optional);                        // Optional[2]

//可以对 Optional 引用重新赋值　
optional = Optional.ofNullable(new AtomicInteger()); 

我们可以通过静态工厂方法empty，of与ofNullable来创建Optional，三者的签名如下：

static <T> Optional<T>  empty()
static <T> Optional<T>  of(T value)
static <T> Optional<T>  ofNullable(T value)

//通过 of 方法创建 Optional
public static <T> Optional<T> createOptionalTheHardWay(T value) {
    return value == null ? Optional.empty() : Optional.of(value);
}

//通过 ofNullable 方法创建 Optional
public static <T> Optional<T> createOptionalTheEasyWay(T value) {
    return Optional.ofNullable(value);
}

ofNullable 方法的实现：检查包含的值是否为 null，若是，则返回一个空 Optional，否则使用 of 方法进行包装。

此外，包装基本数据类型的 OptionalInt、OptionalLong 与 OptionalDouble 类不能为 null，因此三者只有 of 方法，没有 ofNullable 方法。请注意，三个类的 getter 方法分别为 getAsInt、getAsLong 与 getAsDouble，而不是 getInt、getLong 与 getDouble。

static OptionalInt    of(int value)
static OptionalLong   of(long value)
static OptionalDouble of(double value)

---

二、从Optional中检索值

当调用一个返回 Optional 的方法时，可以通过调用 get 方法来检索其中包含的值。如果 Optional 为空，get 方法将抛出 NoSuchElementException。
列如：

Optional<String> firstOdd =
    Stream.of("five", "even", "length", "string", "values")
        .filter(s -> s.length() % 2 != 0)
        .findFirst();

System.out.println(firstOdd.get()); // 抛出NoSuchElementException

我们可以采用多种方案解决这个问题。例如，首先确定 Optional 中是否包含值，然后再检索

Optional<String> firstEven =                                  
    Stream.of("five", "even", "length", "string", "values")
          .filter(s -> s.length() % 2 == 0)
          .findFirst();

System.out.println(
    first.isPresent() ? first.get() : "No even length strings"); 

虽然上述代码可以执行，但只是添加了一个 isPresent 方法进行非空验证，程序并未有太大改进。
所幸我们还有一个更好的选择，这就是非常方便的 orElse 方法，
如果包含的值存在，则 orElse 方法返回该值，否则返回提供的默认值。因此，如果已有回退值（fallback value），那么采用 orElse 方法是相当方便的。

Optional<String> firstOdd =
    Stream.of("five", "even", "length", "string", "values")
        .filter(s -> s.length() % 2 != 0)
        .findFirst();

System.out.println(firstOdd.orElse("No odd length strings"));

orElse 方法包括三种形式。
1：当包含的值存在时，orElse(T other) 将返回该值，否则返回指定的默认值 other。
2：当包含的值存在时，orElseGet(Supplier<? extends T> other) 将返回该值，否则调用 Supplier 并返回相应的结果。
3：当包含的值存在时，orElseThrow(Supplier<? extends X> exceptionSupplier) 将返回该值，否则抛出由 Supplier 产生的异常。

orElse 与 orElseGet 方法的不同之处在于，无论 Optional 中是否存在值，orElse 总会创建新字符串；而 orElseGet 使用 Supplier，仅在 Optional 为空时才执行。
如果值只是一个简单的字符串，那么 orElse 与 orElseGet 方法的区别可以忽略不计；如果 orElse 方法的参数是一个复杂对象，那么传入 Supplier 的 orElseGet 方法能确保仅在需要时才创建对象。
注：采用 Supplier 作为方法参数是延迟执行（deferred execution）或惰性执行（lazy execution）的一种应用，从而可以仅在需要时才在 Supplier 上调用 get 方法。

Optional<ComplexObject> val = values.stream.findFirst()
// 总是创建新对象
val.orElse(new ComplexObject());         
// 仅在需要时才创建对象
val.orElseGet(() -> new ComplexObject()) 

此外，ifPresent 方法支持提供一个仅当 Optional 包含值时才执行的 Consumer

Optional<String> first =
    Stream.of("five", "even", "length", "string", "values")
        .filter(s -> s.length() % 2 == 0)
        .findFirst();
Optional<String> first =
    Stream.of("five", "even", "length", "string", "values")
        .filter(s -> s.length() % 2 == 0)
        .findFirst();

//打印Found an even-length string
first.ifPresent(val -> System.out.println("Found an even-length string"));

first = Stream.of("five", "even", "length", "string", "values")
    .filter(s -> s.length() % 2 != 0)
    .findFirst();
//没执行打印
first.ifPresent(val -> System.out.println("Found an odd-length string"));

---