Java8新特性整理之Optional取代Null引用（六）

﹏ヽ暗。殇╰゛Y 2022-05-31 07:51 221阅读 0赞

## java8之前如何避免空指针异常 ##

相信大家在开发中都会碰到NullPointerException 空指针异常导致程序停止的情况。

下面就来谈谈在java8之前如何避免空指针异常。

一个拥有汽车及汽车保险的客户。

Person.java

public class Person { 
        private Car car; 
        public Car getCar() { return car; } 
    }

Car.java

public class Car { 
        private Insurance insurance; 
        public Insurance getInsurance() { return insurance; } 
    }

Insurance.java

public class Insurance { 
        private String name; 
        public String getName() { return name; } 
    }

现在我们需要获取客户的汽车投保的公司名称，java8之前我们一般这么做：

private String getCarInsuranceName(Person person) {
            if (person != null) {
                Car car = person.getCar();
                if (car != null) {
                    Insurance insurance = car.getInsurance();
                    if (insurance != null) {
                        return insurance.getName();
    
                    }
                }
            }
            return "Unknown";
        }

这是糟糕的，不易阅读的代码。每个null检查都会增加调用链上剩余代码的嵌套层数。

或者：

private String getCarInsuranceName2(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();
        }

这会导致每个null检查都会添加新的退出点。

## java8之后如何避免空指针异常 ##

那么java8中如何优雅的解决上面的问题呢？这就要引入`Optional`类。

变量存在时， Optional类只是对类简单封装。变量不存在时，缺失的值会被建模成一个“空”的Optional对象，由方法Optional.empty()返回。

**null引用和Optional.empty()有什么本质的区别吗？**

从语义上，你可以把它们当作一回事儿，但是实际中它们之间的差别非常大：如果你尝试解引用一个null，一定会触发NullPointerException，不过使用Optional.empty()就完全没事儿，它是Optional类的一个有效对象，多种场景都能调用，非常有用。

使用Optional重新定义Person/Car/Insurance的数据模型  
Person.java

public class Person { 
        private Optional<Car> car;
        public Optional<Car> getCar() { return car; }
    }

Car.java

public class Car { 
        private Optional<Insurance> insurance;
        public Optional<Insurance> getInsurance() { return insurance; }
    }

Insurance.java

public class Insurance { 
        private String name; 
        public String getName() { return name; } 
    }

现在我们需要获取客户的汽车投保的公司名称，java8之前我们一般这么做：

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

解释下，Optional封装的Person对象，创建 Optional 对象 有三种方式：  
1. 声明一个空的Optional

Optional<Person> optPerson = Optional.empty();

1.  依据一个非空值创建Optional

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

1.  可接受null的Optional

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

如果car是null，那么得到的Optional对象就是个空对象。

使用 `flatMap` 和 `map`从 Optional 对象中提取和转换值  
optPerson是Optional类型的变量， 调用map方法应该没有问题。但getCar返回的是一个Optional类型的对象，这意味着map操作的结果是一个Optional

public class Person { 
        private Car car; 
        public Optional<Car> getCarAsOptional() { 
            return Optional.ofNullable(car); 
        } 
    }

Optional类提供了多种方法**读取Optional实例中的变量值**：  
\- `get()`是这些方法中最简单但又最不安全的方法。如果变量存在，它直接返回封装的变量值，否则就抛出一个NoSuchElementException异常。所以，除非你非常确定Optional  
变量一定包含值，否则使用这个方法是个相当糟糕的主意。此外，这种方式即便相对于嵌套式的null检查，也并未体现出多大的改进。  
\- `orElse(T other)`，它允许你在Optional对象不包含值时提供一个默认值。  
\- `orElseGet(Supplier<? extends T> other)`是orElse方法的延迟调用版， Supplier  
方法只有在Optional对象不含值时才执行调用。如果创建默认值是件耗时费力的工作，你应该考虑采用这种方式（借此提升程序的性能），或者你需要非常确定某个方法仅在  
Optional为空时才进行调用，也可以考虑该方式（这种情况有严格的限制条件）。  
\- `orElseThrow(Supplier<? extends X> exceptionSupplier)`和get方法非常类似，  
它们遭遇Optional对象为空时都会抛出一个异常，但是使用orElseThrow你可以定制希望抛出的异常类型。  
\- `ifPresent(Consumer<? super T>)`让你能在变量值存在时执行一个作为参数传入的方法，否则就不进行任何操作。

### 使用 Optional的filter方法过滤特定条件 ###

需求：你可能需要检查保险公司的名称是否为“香港保险”

java8之前需要这么做：

public void testGetInsuranceName(Car car) {
            Insurance insurance = car.getInsurance();
            if(insurance != null && "香港保险".equals(insurance.getName())) {
                System.out.println("ok");
            }
        }

java8之后这么做：

public void testGetInsuranceName2(Car car) {
            Optional<Insurance> optInsurance = car.getInsurance();
            optInsurance.filter(insurance -> "香港保险".equals(insurance.getName()))
                    .ifPresent(x -> System.out.println("ok"));
        }

`filter`方法接受一个谓词作为参数，如果Optional对象的值存在，并且它符合谓词的条件，filter方法就返回其值；否则它就返回一个空的Optional对象。

**基础类型的Optional对象，以及为什么应该避免使用它们**

不知道你注意到了没有，与Stream对象一样，Optional也提供了类似的基础类型——`OptionalInt`、`OptionalLong`以及`OptionalDouble`。

之前讨论过使用基础类型Stream的场景，尤其是如果Stream对象包含了大量元素，出于性能的考量，  
使用基础类型是不错的选择，但对Optional对象而言，这个理由就不成立了，因为**Optional对象最多只包含一个值**。

## 小结 ##

*  null引用在历史上被引入到程序设计语言中，目的是为了表示变量值的缺失。
 *  Java 8中引入了一个新的类java.util.Optional，对存在或缺失的变量值进行建模。
 *  你可以使用静态工厂方法Optional.empty、Optional.of以及Optional.ofNullable创建Optional对象。
 *  Optional类支持多种方法，比如map、flatMap、filter，它们在概念上与Stream类中对应的方法十分相似。
 *  使用Optional会迫使你更积极地解引用Optional对象，以应对变量值缺失的问题，最终，你能更有效地防止代码中出现不期而至的空指针异常。
 *  使用Optional能帮助你设计更好的API，用户只需要阅读方法签名，就能了解该方法是否接受一个Optional类型的值。