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

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

依据一个非空值创建Optional

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

可接受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类型的值。