Optional 详解

作为一名 Java 程序员，我真的是烦透了 NullPointerException（NPE），尽管和它熟的像一位老朋友，知道它也是迫不得已——程序正在使用一个对象，却发现这个对象的值为 null，于是 Java 虚拟机就怒发冲冠的把它抛出来当作替罪羊。

当然了，我们程序员是富有责任心的，不会坐视不管，于是就有了大量的 null 值检查。尽管有时候这种检查完全没必要，但我们已经习惯了例行公事。终于，Java 8 看不下去了，就引入了 Optional，以便于我们编写的代码不再那么刻薄呆板。

1、Optional 介绍

• Optional 类是一个可以为 null 的容器对象。如果值存在则 isPresent() 方法会返回 true，调用 get() 方法会返回该对象。
• Optional 是一个容器：它可以保存类型 T 的值，或者仅仅保存 null。Optional 提供很多有用的方法，这样我们就不用显示进行空值检测。
• Optional 类的引用很好的解决了空指针异常。

2、创建 Optional 对象

1）可以使用静态方法 empty()创建一个空的 Optional 对象

Optional<Object> empty = Optional.empty();
System.out.println(empty); // 输出：Optional.empty

2）可以使用静态方法of()创建一个非空的 Optional 对象

Optional<Object> opt = Optional.of("王二");
System.out.println(opt); // 输出：Optional[王二]

当然了，传递给of()方法的参数必须是非空的，也就是说不能为 null ，否则仍然会抛出 NullPointerException。

3）可以使用静态方法ofNullable()创建一个即可空又可非空的 Optional 对象

String name = null;
Optional<String> optOrNull = Optional.ofNullable(name);
System.out.println(optOrNull); // 输出：Optional.empty

ofNullable()方法内部有一个三元表达式，如果参数为 null，则返回私有常量 empty；否则使用 new 关键字创建一个心的 Optional 对象——不会再抛出 NPE 异常了。

3、Optional 常用方法

1. 判断值是否存在 — isPresent()

isPresent()方法可以判断一个 Optional 对象是否存在，如果存在，返回 true，否则返回 false。该方法取代了 obj != null 的判断

Optional<String> opt = Optional.of("王二");
System.out.println(opt.isPresent()); // 输出：true

Optional<String> optOrNull = Optional.ofNullable(null);
System.out.println(opt.isPresent()); // 输出：false

Java 11 后还可以通过方法isEmpty()(判断值是否为空)，判断与isPresent()相反的结果

Optional<String> opt = Optional.of("王二");
System.out.println(opt.isEmpty()); // 输出：false

Optional<String> optOrNull = Optional.ofNullable(null);
System.out.println(opt.isEmpty()); // 输出：true

2. 非空表达式 — ifPresent()

ifPresent()是 Optional 类的一个非常现代化的方法，允许我们使用函数式编程的方法执行一些代码。如果没有该方法的话，我们通常需要先通过isPresent()方法对 Optional 对象进行判空后再执行相应的代码：

Optional<String> optOrNull = Optional.ofNullable(null);
if (optOrNull.isPresent()) {
    System.out.println(optOrNull.get().length());
}

而有了ifPresent()之后，情况就完全不同了，可以直接讲 Lambda 表达式传递给该方法，代码更加简洁、直观。

Optional<String> opt = Optional.of("王二");
opt.ifPresent(x -> System.out.println(x.length()));

Java 9 后还可以通过方法ifPresentOrElse(action, emptyAction)执行两种结果，非空时执行 action，空时执行 emptyAction。

Optional<String> opt = Optional.of("王二");
opt.ifPresentOrElse(x -> System.out.println(x.length()), () -> System.out.println("为空"));

3. 设置(获取)默认值 — orElse()、orElseGet()

有时候，我们在创建(获取) Optional 对象的时候，需要一个默认值，orElse()和orElseGet()方法就派上用场了。
orElse()方法用于返回包裹在 Optional 对象中的值，如果该值不为 null ，则返回；否则返回默认值。该方法的参数类型和值的类型一致

String nullName = null;
String name = Optional.ofNullable(nullName).orElse("王二");
System.out.println(name); // 输出：王二

orElseGet()方法与orElse()类似，但参数类型不同。如果 Optional 对象中的值为 null，则执行参数中的函数

String nullName = null;
String name = Optional.ofNullable(nullName).orElseGet(()->"沉默王二");
System.out.println(name); // 输出：沉默王二

从输出结果以及代码的形式上来看，这两个方法极其相似，这不免引起我们的怀疑，Java 类库的设计者有必要这做吗？
假设现在有这样一个获取默认值的方法，很传统的方式。

public static String getDefaultValue() {
        System.out.println("www111");
        return "w1";
 }

然后通过orElse()与orElseGet()方法分别调用getDefaultValue()返回默认值：

String nullName = null;
String orElse = Optional.ofNullable(nullName).orElse(getDefaultValue());
System.out.println("orElse: "+ orElse);
// 类名::方法名 是 Java 8 引入的语法，方法名后面没有 () 的，表明该方法不一定会被调用
String orElseGet = Optional.ofNullable(nullName).orElseGet(QuesRecordServiceImpl::getDefaultValue);
System.out.println("orElseGet: "+ orElseGet);

System.out.println("======================");

String name = "w2";
String orElse2 = Optional.ofNullable(name).orElse(getDefaultValue());
System.out.println("orElse2: "+ orElse2);
String orElseGet2 = Optional.ofNullable(name).orElseGet(QuesRecordServiceImpl::getDefaultValue);
System.out.println("orElseGet2: "+ orElseGet2);

结果如下：

咦，在 Optional 对象的值不为 null 时，orElseGet()没有去调用getDefaultValue()。哪个方法的性能更佳，你明白了吧？

4. 获取值 — get()

直观从语义上来看，get()方法才是最正宗的获取 Optional 对象值的方法，但很遗憾，该方法是有缺陷的，因为假如 Optional 对象的值为 null，该方法会抛出 NoSuchElementException 异常。这完全与我们使用 Optional 类的初衷相悖。

public class GetOptionalDemo {
    public static void main(String[] args) {
        String name = null;
        Optional<String> optOrNull = Optional.ofNullable(name);
        System.out.println(optOrNull.get());
    }
}

这段程序在运行时会抛出异常：

尽管抛出的异常是 NoSuchElementException 而不是 NEP，但在我们看来，显然是 “五十步笑百步”。建议使用orElseGet()方法获取 Optional 对象的值。

5. 过滤值 — filter()

filter()方法可以传入一个 Lambda 表达式作为条件，如果表达式结果为 false，则返回一个 empty 的 Optional 对象，否则返回过滤后的 Optional 对象。

String password = "12345";
Optional<String> opt = Optional.ofNullable(password);
System.out.println(opt.filter(pwd -> pwd.length() > 6).isPresent()); // 输出：false

filter()方法的参数类型为 Predicate（Java 8 新增的一个函数式接口），在上例中，由于 password 所以结果为 false。假设密码长度要求在 6 到 10 位之间，那么还可以再追加一个条件：

Predicate<String> len6 = pwd -> pwd.length() > 6;
Predicate<String> len10 = pwd -> pwd.length() < 10;

password = "1234567";
opt = Optional.ofNullable(password);
boolean result = opt.filter(len6.and(len10)).isPresent();
System.out.println(result); // 输出：true

这次结果为 true。因为密码变成了 7 位，符合条件。想象一下，假如使用 if-else 来完成这个任务，代码该有多冗长。

6. 转换值 — map()

map()方法可以按照一定的规则将原有 Optional 对象转换为一个新的 Optional 对象，原有的 Optional 对象不会更改。

String name = "王二";
Optional<String> nameOptional = Optional.of(name);
Optional<Integer> intOpt = nameOptional.map(String::length);

System.out.println( intOpt.orElse(0)); // 输出：2

在上面这个例子中，map()方法的入参String::length，意味着要将原有字符串类型的 Optional 按照字符串长度重新生成一个新的 Optional 对象，类型为 Integer。
当入参也是一个 Optional 时，经过map()转化后会形成一个 Optional<Optional< Integer >> 这种嵌套结构；但flatMap()可以把这种嵌套结构打开：

Optional<Optional<Integer>> unFlatMap = nameOptional.map(x -> Optional.of(x.length()));
Optional<Integer> flatMap = nameOptional.flatMap(x -> Optional.of(x.length()));

---

好事定律：每件事最后都会是好事，如果不是好事，说明还没到最后。