「这是我参与11月更文挑战的第4天，活动详情查看：2021最后一次更文挑战」。

一、null带来了哪些问题？

1）NullPointerException 是目前Java程序开发中最典型的异常。

2）它会使你的代码膨胀。它让你的代码充斥着深度嵌套的 null 检查。

3）它自身是毫无意义的。

4）它破坏了Java的哲学。Java一直试图避免让程序员意识到指针的存在，唯一的例外是： null 指针。

5）它在Java的类型系统上开了个口子。null 并不属于任何类型，这意味着它可以被赋值给任意引用类型的变量。

简单举例，有一辆汽车car，汽车有没有上保险呢？我们通过车的对象获取一下，看看保险的名字，代码如下

java复制代码import lombok.Data;

/**
 * @description： TestOptional
 * @author：weirx
 * @date：2021/10/26 14:26
 * @version：3.0
 */
public class TestOptional {

    @Data
    static class Car{

        private Insurance insurance;

        private String name;
    }

    @Data
    static class Insurance{

        private String name;
    }
    
    public static void main(String[] args) {
        Car car = new Car();
        car.getInsurance().getName();
    }
}

结果：

1 2	php复制代码Exception in thread "main" java.lang.NullPointerException at com.cloud.bssp.java8.Optional.TestOptional.main(TestOptional.java:31)

如上所示，报了我们深恶痛绝的空指针异常，怎么防止呢？无非就是增加非空判断：

1	java复制代码car.getInsurance() == null ? null : car.getInsurance().getName();

虽然上面的代码解决了空指针的问题，但是无形中增加了代码的复杂程度，可读性。

二、Optional 类入门

汲取 Haskell 和 Scala 的灵感，Java 8中引入了一个新的类 java.util.Optional 。这是一个封装 Optional 值的类。

如上面的空指针例子中，如果不知道车到底有没有保险，就不应该将保险声明为Insurance，而是应该声明为Optional。

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

使用Optional我们可以像下面这么声明：

java复制代码    static class Car {

        private Optional<Insurance> insuranceOptional;

        private String name;
    }

在语义上来讲，使用Optional来声明你的类，能非常清晰地界定出变量值的缺失是结构上的问题，还是你算法上的缺陷，抑或是你数据中的问题。

三、Optional使用

3.1 创建Optional对象

java复制代码        // 1、声明一个空Optional
        Optional<Car> optional1 = Optional.empty();

        // 2、依据一个非空值创建Optional，如果传入一个null，则会抛出空指针异常
        Optional<Car> optional2 = Optional.of(new Car());

        // 3、可接受null的Optional：使用静态工厂方法 Optional.ofNullable ，你可以创建一个允许 null 值的 Optional
        // 如果 car 是 null ，那么得到的 Optional 对象就是个空对象。
        Optional<Car> optional3 = Optional.ofNullable(null);

3.2 使用 map 从 Optional 对象中提取和转换值

Optional 提供了一个 map 方法，使用方式如下：

1 2	java复制代码 Optional<Car> optionalCar = Optional.ofNullable(car); Optional<String> optionalName = optionalCar.map(Car::getName);

与之前的文章当中我们学习Stream中的map比较相像。

那么如果我们想要获取保险的名称怎么获取呢？

java复制代码        Car car = new Car();
        car.setInsuranceOptional(Optional.empty());
        Optional<Car> optionalCar = Optional.ofNullable(car);
        optionalCar.map(Car::getInsuranceOptional).map(Insurance::getName);

如上这个代码是无法通过编译的。getInsuranceOptional返回的是Optional对象，接下来的map操作就成了对Optional对象操作getName命令，这是违法的。

3.3 使用 flatMap 链接 Optional 对象

为了解决前面的问题，此时我们可以使用flatMap方法，与Stream中的flatMap有相同的效果。我们这里要做的是将两层Optional合并成一个Optional：

java复制代码        Car car = new Car();
        car.setInsuranceOptional(Optional.empty());
        Optional<Car> optionalCar = Optional.ofNullable(car);
        optionalCar.flatMap(Car::getInsuranceOptional).map(Insurance::getName);

如上所示我们给出的car中Insurance是空Optional，虽然运行上面的代码不会咋抛出空指针异常了，但是我们仍需要对其有个处理的话可以使用orElse()，如下所示：

java复制代码        Car car = new Car();
        car.setInsuranceOptional(Optional.empty());
        Optional<Car> optionalCar = Optional.ofNullable(car);
        String unknown = optionalCar.flatMap(Car::getInsuranceOptional).map(Insurance::getName).orElse("unknown");
        System.out.println(unknown);

-----------输出---------------
unknown

3.4 读取Optional对象中的值

3.4.1 get()

get() 是这些方法中最简单但又最不安全的方法。如果变量存在，它直接返回封装的变量值，否则就抛出一个NoSuchElementException 异常。

除非你非常确定 Optional变量一定包含值，否则使用这个方法是个相当糟糕的主意。

此外，这种方式即便相对于嵌套式的 null 检查，也并未体现出多大的改进。

java复制代码        Car car = new Car();
        car.getInsuranceOptional().get();

--------输出-----------
Exception in thread "main" java.util.NoSuchElementException: No value present
	at java.util.Optional.get(Optional.java:135)
	at com.cloud.bssp.java8.Optional.TestOptional.main(TestOptional.java:36)

3.4.2 orElse(T other)

orElse(T other)是在前面的例子中提到的方法。它允许你在Optional 对象不包含值时提供一个默认值。

java复制代码        Car car = new Car();
        car.setInsuranceOptional(Optional.empty());
        Optional<Car> optionalCar = Optional.ofNullable(car);
        String unknown = optionalCar.flatMap(Car::getInsuranceOptional).map(Insurance::getName).orElse("unknown");
        System.out.println(unknown);

-----------输出---------------
unknown

3.4.3 orElseGet(Supplier<? extends T> other)

orElse 方法的延迟调用版。

Supplier方法只有在 Optional 对象不含值时才执行调用。

如果创建默认值时需要执行其他的方法做一些操作时，或者你需要非常确定某个方法仅在Optional 为空时才进行调用，也可以考虑该方式（这种情况有严格的限制条件）。

java复制代码    public static String test() {
        System.out.println("this car has no insurance");
        return "unknown";
    }

        Car car = new Car();
        car.setInsuranceOptional(Optional.empty());
        Optional<Car> optionalCar = Optional.ofNullable(car);
        String unknown = optionalCar.flatMap(Car::getInsuranceOptional).map(Insurance::getName).orElseGet(TestOptional::test);
        System.out.println(unknown);

-------输出--------
this car has no insurance
unknown

3.4.4 orElseThrow(Supplier<? extends X> exceptionSupplier)

和 orElseGet方法非常类似，它们遭遇 Optional 对象为空时都会抛出一个异常，但是使用 orElseThrow 你可以定制希望抛出的异常类型。

java复制代码    static class MyException extends RuntimeException{

    }

        Car car = new Car();
        car.setInsuranceOptional(Optional.empty());
        Optional<Car> optionalCar = Optional.ofNullable(car);
        String unknown = optionalCar.flatMap(Car::getInsuranceOptional).map(Insurance::getName).orElseThrow(MyException::new);
        System.out.println(unknown);

-------输出-----------
Exception in thread "main" com.cloud.bssp.java8.Optional.TestOptional$MyException
	at java.util.Optional.orElseThrow(Optional.java:290)
	at com.cloud.bssp.java8.Optional.TestOptional.main(TestOptional.java:42)

3.4.5 ifPresent(Consumer<? super T>)

能在变量值存在时执行一个作为参数传入的方法，否则就不进行任何操作。

java复制代码    static void addName(String name){
        System.out.println("the insurance is : " + name);
    }

        Car car = new Car();
        Insurance insurance = new Insurance();
        insurance.setName("车险");
        car.setInsuranceOptional(Optional.of(insurance));
        Optional<Car> optionalCar = Optional.ofNullable(car);
        optionalCar.flatMap(Car::getInsuranceOptional).map(Insurance::getName).ifPresent(TestOptional::addName);

--------------输出--------------
the insurance is : 车险

3.4.6 isPresent

如果存在就返回true，不存在就返回false。

java复制代码        Car car = new Car();
        car.setInsuranceOptional(Optional.empty());
        System.out.println(car.getInsuranceOptional().isPresent());

        Insurance insurance = new Insurance();
        insurance.setName("车险");
        car.setInsuranceOptional(Optional.of(insurance));
        System.out.println(car.getInsuranceOptional().isPresent());

--------------输出--------------
false
true

3.4.7 filter(Predicate<? super T> predicate)

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

java复制代码        Car car = new Car();
        Insurance insurance = new Insurance();
        insurance.setName("车险");
        car.setInsuranceOptional(Optional.of(insurance));
        Optional<Car> optionalCar = Optional.ofNullable(car);
        Optional<String> s = optionalCar.flatMap(Car::getInsuranceOptional).map(Insurance::getName).filter("车险"::equals);
        System.out.println(s.get());

------------输出-----------
车险

兄弟们，看完有收获，点个赞吧

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有