Java8 Optional

作者: AC编程 | 来源:发表于2022-10-10 16:51 被阅读0次

一、简介

到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。

Optional实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

此处引用java 8实战里面的描述：

在你的代码中始终如一地使用Optional，能非常清晰地界定出变量值的缺失是结构上的问题，还是你算法上的缺陷，抑或是你数据中的问题。另外，我们还想特别强调，引入Optional类的意图并非要消除每一个null引用。与此相反，它的目标是帮助你更好地设计出普适的API，让程序员看到方法签名，就能了解它是否接受一个Optional的值。这种强制会让你更积极地将变量从Optional中解包出来，直面缺失的变量值。

所以，optional的作用是显示的表达变量的状态，而不是为了完全消灭NPE。

二、是否使用Optional对比

2.1 不使用Optional

/**
 * 常规实现：根据客户信息获取车辆保险公司的名称
 *
 * @param person
 * @return
 */
public static String getCarInsuranceName(Person person) {
    //对客户判空
    if (person == null) {
        return "Unknown";
    }
    //对车辆判空
    Car car = person.getCar();
    if (car == null) {
        return "Unknown";
    }
    //对保险公司判空
    Insurance insurance = car.getInsurance();
    if (insurance == null) {
        return "Unknown";
    }
    return insurance.getName();
}

以上代码，可能是我日常开发经常遇到的，过多的NullPointerException检查，影响到了代码的可读性以及优雅性，而且存在潜在的风险，假设其中某个环节未做空指针的检查，则会看到我们熟悉而又讨厌的NullPointerException。

2.2 使用Optional

/**
 * Optional实现：根据客户信息获取车辆保险公司的名称
 *
 * @param person
 * @return
 */
public static String getCarInsuranceName2(Person person) {
    //当Optional对象为空时，则后面的map都不会继续执行
    return Optional.ofNullable(person)
            .map(Person::getCar)
            .map(Car::getInsurance)
            .map(Insurance::getName)
            .orElse("Unknown");
}

2.3 测试

public static void main(String[] args) {
    //测试1
    Person person = new Person();
    System.out.println(getCarInsuranceName(person));
    System.out.println(getCarInsuranceName2(person));
    System.out.println("--------------------------");

    //测试2
    Insurance insurance = new Insurance("xx保险公司");
    Car car = new Car(insurance);
    Person person2 = new Person(car);
    System.out.println(getCarInsuranceName(person2));
    System.out.println(getCarInsuranceName2(person2));
}

运行结果

Unknown
Unknown
--------------------------
xx保险公司
xx保险公司

三、Optional的构造方式

为了控制生成实例的方式，也是为了收紧空值Optional的定义，Optional将构造函数定义为private。想要创建Optional实例，可以借助of和ofNullable两个方法实现。这两个方法的区别在于：of方法传入的参数不能是null的，否则会抛出NullPointerException。所以，对于可能是null的结果，一定使用ofNullable。

Optional类中还有一个静态方法：empty，这个方法直接返回了内部定义的一个常量Optional<?> EMPTY = new Optional<>()，这个常量的value是null。ofNullable方法也是借助了empty实现null的包装。所以说，对于null的Optional包装类，指向的都是相同的实例对象，Optional.empty() == Optional.ofNullable(null)返回的是true。换句话说，空Optional是单例的。

3.1 Optional.of(T)

该方式的入参不能为null，否则会有NPE，在确定入参不为空时使用该方式。

3.2 Optional.ofNullable(T)

该方式的入参可以为null，当入参不确定为非null时使用。

3.3 Optional.empty()

这种方式是返回一个空Optional，等效Optional.ofNullable(null)

四、常用函数

4.1 of

为非null的值创建一个Optional。of方法通过工厂方法创建Optional类。需要注意的是，创建对象时传入的参数不能为null。如果传入参数为null，则抛出NullPointerException。因此不经常用。

Optional<Person> personOpt = Optional.of(person);

4.2 ofNullable

为指定的值创建一个Optional，如果指定的值为null，则返回一个空的Optional。

Optional<Person> personOpt = Optional.ofNullable(person);

4.3 isPresent

如果值存在返回true，否则返回false。

public static String getGender(Student student){
    Optional<Student> stuOpt =  Optional.ofNullable(student);
    if(stuOpt.isPresent())
    {
        return stuOpt.get().getGender();
    }

    return "Unkown";
}

这种用法不但没有减少null的防御性检查，而且增加了Optional包装的过程，违背了Optional设计的初衷，因此开发中要避免这种糟糕的使用。

4.4 ifPresent

如果Optional实例有值则为其调用consumer，否则不做处理。

public static void printName(Student student){
    Optional.ofNullable(student).ifPresent(u ->  System.out.println("The student name is : " + u.getName()));
}

4.5 get

如果Optional有值则将其返回，否则抛出NoSuchElementException。因此也不经常用。

4.6 orElse

如果有值则将其返回，否则返回指定的其它值。

public static String getName(Person person) {
    return Optional.ofNullable(person).map(Person::getName).orElse("Unknown");
}

4.7 orElseGet

orElseGet与orElse方法类似，区别在于得到的默认值。orElse方法传入的参数是明确的默认值，orElseGet方法传入的参数是获取默认值的函数。

如果默认值的构造过程比较复杂，需要经过一系列的运算逻辑，那一定要使用orElseGet，因为orElseGet是在值为空的时候，才会执行函数，并返回默认值，如果值不为空，则不会执行函数，相比于orElse而言，减少了一次构造默认值的过程。

Optional<Wallet> findByAccountId(Integer accountId);

//为null时，创建一下新的
Wallet wallet = repository.findByAccountId(accountId).orElseGet(() -> {
           Wallet newWallet = new Wallet();
           Account account = new Account();
           account.setId(accountId);
           newWallet.setMoney(0D);
           newWallet.setAccount(account);
           repository.save(newWallet);
           return newWallet;
       });

4.8 orElseThrow

如果有值则将其返回，否则抛出supplier接口创建的异常。

Account account = Optional.ofNullable(databaseUserRepo.findByUsername(username)).orElseThrow(() -> new UsernameNotFoundException("用户" + username + "不存在"))

4.9 filter

如果有值并且满足断言条件返回包含该值的Optional，否则返回空Optional。

public static void filterAge(Student student){
    Optional.ofNullable(student).filter( u -> u.getAge() > 18).ifPresent(u ->  System.out.println("The student age is more than 18."));
}

4.10 map

如果有值，则对其执行调用mapping函数得到返回值。如果返回值不为null，则创建包含mapping返回值的Optional作为map方法返回值，否则返回空Optional。

map()方法的源码：

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));
   }
}

map()方法的参数为Function（函数式接口）对象，map()方法将Optional中的包装对象用Function函数进行运算，并包装成新的Optional对象（包装对象的类型可能改变）。举例如下：

public static String getCarInsuranceName2(Person person) {
    //当Optional对象为空时，则后面的map都不会继续执行
    return Optional.ofNullable(person)
            .map(Person::getCar)
            .map(Car::getInsurance)
            .map(Insurance::getName)
            .orElse("Unknown");
}

4.11 flatMap

如果有值，为其执行mapping函数返回Optional类型返回值，否则返回空Optional。

flatMap()方法的源码：

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

跟map()方法不同的是，入参Function函数的返回值类型为Optional<U>类型，而不是U类型，这样flatMap()能将一个二维的Optional对象映射成一个一维的对象，faltMap()改写如下：

public static String getCarInsuranceName3(Person person) {
    //当Optional对象为空时，则后面的flatMap都不会继续执行
    return Optional.ofNullable(person)
            .flatMap(e -> Optional.ofNullable(e.getCar()))
            .flatMap(c -> Optional.ofNullable(c.getInsurance()))
            .map(Insurance::getName)
            .orElse("Unknown");
}

map和flatMap是对Optional的值进行操作的方法，区别在于，map会将结果包装到Optional中返回，flatMap不会。但是两个方法返回值都是Optional类型，这也就要求，flatMap的方法函数返回值需要是Optional类型。

4.12 其他：equals、hashCode、toString

Optional重写了这三个方法。因为Optional可以认为是包装类，所以还是围绕这被包装的值重写这三个方法。

equals方法，Optional.of(s1).equals(Optional.of(s2))完全等价于s1.equals(s2)。
hashCode方法，直接返回的是值的hashCode，如果是空Optional，返回的是0。
toString方法，为了能够识别是Optional，将打印数据包装了一下。如果是空Optional，返回的是字符串“Optional.empty”；如果是非空，返回是是“Optional[值的toString]”。

五、正确使用Optional

5.1 尽量避免使用的地方

1、避免使用Optional.isPresent()来检查实例是否存在，因为这种方式和null != obj没有区别，这样用就没什么意义了。

2、避免使用Optional.get()方式来获取实例对象，因为使用前需要使用Optional.isPresent()来检查实例是否存在，否则会出现NPE问题。

3、避免使用Optional作为类或者实例的属性，而应该在返回值中用来包装返回实例对象。

4、避免使用Optional作为方法的参数，原因同3。

5.2 示例

使用Optional，我们就可以把下面这样的代码进行改写

public static String getName(Person person) {
    if (person == null) {
        return "Unknown";
    }
    return person.getName();
}

不过，千万不要改写成这副样子

public static String getName(Person person) {
    Optional<Person> personOpt = Optional.ofNullable(person);
    if (!personOpt.isPresent()) {
        return "Unknown";
    }
    return person.getName();
}

这样改写非但不简洁，而且其操作还是和第一段代码一样。无非就是用isPresent方法来替代u==null。这样的改写并不是Optional正确的用法，我们再来改写一次。

public static String getName(Person person) {
    return Optional.ofNullable(person).map(Person::getName).orElse("Unknown");
}

这样才是正确使用Optional的姿势。那么按照这种思路，我们可以安心的进行链式调用，而不是一层层判断了。