使用Optional，不再头疼NPE

作者：@后青春期的Keats
本文为作者原创，转载请注明出处：https://www.cnblogs.com/keatsCoder/p/12884863.html

---

• 前言
• Optional 入门
• 创建 Optional 对象
• map --- 从 Optional 中提取和转换值
• 更优雅的判断语句
• 其他

前言

在 Java 语言开发中，可能大多数程序员遇到最多的异常就是 NullPointException 空指针异常了。这个当初语言的开发者“仅仅因为这样实现起来更容易”而允许空引用所带来的代价是非常惨痛的。而我们开发者不得不使用多重 if 嵌套判断来规避 NPE 或者通过多个 if 结合 return 语句来终止程序。且看一个例子

假如需要处理下面的嵌套对象，这是一个用于汽车、汽车保险的客户。

public class Person {
    private Car car;
    public Car getCar() {
        return car;
    }
}
public class Car {
    private Insurance insurance;
    public Insurance getInsurance() {
        return insurance;
    }
}
public class Insurance {
    private String name;
    public String getName() {
        return name;
    }
}

那么下面的代码会存在怎样的问题呢？

public String getCarInsuranceNames(Person person) {
    return person.getCar().getInsurance().getName();
}

没错，当这个人没有车 / 他的车没有上保险时，代码会抛出 NPE。或者说这个人根本就是 null，也会直接抛出异常。我们常见的作法就是在每次 get 方法之后，进行 if 判断，增加代码的健壮性。可是这样代码会显得十分臃肿。Java 语言的开发者们也在关注着这些问题。因此在 Java8 提供了新的 API：java.util.Optional 用来优雅的处理 null。接下来就请读者和我一起揭开 Optional 神秘的面纱吧！

PS：Optional 类提供的很多 API 结合 Lambda 表达式食用更佳，另外还有很多 API 和 Stream 流中同名 API 的思想基本一致。因此建议读者先行了解这两个知识点，可以在我的博客 Java8新特性 标签下学习

声明：本文首发于博客园，作者：后青春期的Keats；地址：https://www.cnblogs.com/keatsCoder/ 转载请注明，谢谢！

Optional 入门

Optional 类是一个封装 T 值的类，变量 T 存在时，Optional 只是对他做一个简单的封装，如果 T 不存在，缺失的值会被建模成一个空对象，由 Optional.empty() 返回。下面这张图可以形象的描述 Optional

现在我们尝试着重构之前关于 人 车 保险 的代码

public class Person {
    private Optional<Car> car;
    public Optional<Car> getCar() {
        return car;
    }
}
public class Car {
    private Optional<Insurance> insurance;
    public Optional<Insurance> getInsurance() {
        return insurance;
    }
}
public class Insurance {
    private String name;
    public String getName() {
        return name;
    }
}

注意：对于保险来说，我们从逻辑层面限定每个保险公司都有名称，如果没有，那一般是数据出了问题而非代码的问题，开发者应该着手去寻找为什么数据库存在名字为空的保险公司。而不是这里抛出 NPE，故而我们不用将 Insurance 的 name 字段使用 Optional 包裹

通过上面的代码，我们已经将对象由 Optional 所包裹了，那接下来我们该如何使用它呢？

创建 Optional 对象

创建一个空对象

Optional<Object> empty = Optional.empty();

Optional.empty(); 该方法返回一个空对象，

根据一个非空值创建

Optional<Car> car = Optional.of(c);

Optional.of(T t); 方法会返回一个 Optional 对象，但是需要注意，如果 of 方法参数是 null，该行会抛出 NPE。

允许空值创建

Optional car = Optional.ofNullable(c);

为了避免在创建 Optional 对象时，由于源对象为空而引发的 NPE，该类还提供了 ofNullable 方法，当参数为 null 时，返回 Optional.empty()。内部的 API 是这样的

public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

map --- 从 Optional 中提取和转换值

public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent()) {
        return empty();
    } else {
        return Optional.ofNullable(mapper.apply(value));
    }
}

Optional 类提供 map 方法，接收一个函数式接口 Function 的实现类，如果调用者是空的，则返回 empty(),否则对 Optional 中的对象 value 调用 Function 实现类中的 apply() 方法，再包装成 Optional 返回。可以用下面的图直观的看到 map 执行的过程：

请注意，在 map 执行完 apply 方法拿到返回值之后，会主动将返回值再次包裹成 Optional 对象。因此我们如果按照下面的方式改造我们之前的方法，编译是无法通过的：

person.map(Person::getCar).map(Car::getInsurance).map(Insurance::getName);

我们来分析一下： person.map(Person::getCar) 改造后的 person 类中， getCar 方法返回 Optional 对象，而 map 又将 Optional 包装到 Optional 中，形成 Optional<Optional> emmm...套娃式包装。两层包装的 car 是无法通过 map 在调用 getInsurance 方法的。

幸运的是，和 Stream 一样，Optional 也提供了扁平化流的方法 flatMap()。且看源码

public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent()) {
        return empty();
    } else {
        @SuppressWarnings("unchecked")
        Optional<U> r = (Optional<U>) mapper.apply(value);
        return Objects.requireNonNull(r);
    }
}
 

flatMap() 比 map() 方法多了一个执行完后将嵌套 Optional 强转成 Optional 的操作，避免了流不能继续使用的尴尬处境。因此，我们可以将获取保险公司名称的方法改造成下面这样：

public String getCarInsuranceName(Optional<Person> person) {
    return person.flatMap(Person::getCar)
        .flatMap(Car::getInsurance)
        .map(Insurance::getName)
        .orElse("Unknown");
}
 

其中 orElse() 方法表示当最终 Optional 包裹的对象还是空时，返回的默认值

PS：由于 Optional 并没有实现序列化接口，因此如果你的项目中使用了某些要求序列化的框架，并且在某个类中使用 Optional 包裹了字段。可能会由序列化引发程序故障。

操作 Optional 中的变量

get()

通过 get() 方法获取变量，如果变量存在就直接得到该变量，否则抛出一个 throw new NoSuchElementException("No value present"); 异常。一般不建议使用该方法毕竟直接用 get() 方法了，还要整 Optional 这些花里胡哨的干啥呢

orElse()

在对象为 null 时提供一个默认值

orElseGet(Supplier<? extends T> other)

在对象为 null 通过调用 supplier 提供者接口的实现，返回一个值

orElseThrow()

在对象为 null 抛出一个可定制的异常信息，可以用来抛出项目中的自定义异常，以便全局异常捕获器抓取及响应数据

ifPresent(Consumer<? super T> action)

当对象不为 null 时，执行消费者操作。为 null 时啥也不干

更优雅的判断语句

我们常常调用某个对象的某个方法去判断其属性。为了安全操作。首先需要对该对象进行非空校验。例如要检查保险公司名称是否为 Keats，需要这么写

if(i != null && "Keats".equals(i.getName())){
    System.out.println("yes");
}
 

现在我们可以这么写

Optional<Insurance> insurance = Optional.ofNullable(i);
insurance.filter(in -> "Keats".equals(in.getName())).ifPresent(in -> System.out.println("yes"));
 

先看 filter 的源码

public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent()) {
        return this;
    } else {
        return predicate.test(value) ? this : empty();
    }
}
 

首先第一步检查了谓词实现非空，第二步判断 Optional 中的对象如果为空则返回空 Optional，如果不为空执行谓词方法，条件成立则返回该对象。否则返回空 Optional。即仅当 Optional 中对象不为 null 且符合条件时，返回该对象之后通过 ifPresent() 方法执行接下来的逻辑。非常方便易懂

其他

Optional 还提供了一些基础类型对象对应的类，如 OptionalInt、OptionalLong 同 Stream 流一样，采用基本操作类型处理数据，避免了自动拆装箱带来的性能损失。但却牺牲了 map、flatMap、filter 方法。开发中需酌情使用

码字不易，如果你觉得读完以后有收获，不妨点个推荐让更多的人看到吧！