使用Optional,不再头疼NPE

前言

在 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

1589295110199

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

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 执行的过程:

1589296375952

请注意,在 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 方法。开发中需酌情使用

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

posted @ 2020-05-13 20:58  后青春期的Keats  阅读(635)  评论(1编辑  收藏  举报