JDK1.8新特性 Optional判空详解，简化判空操作

一、简介

从 Java 8 引入的一个很有趣的特性是 Optional 类。Optional 类主要解决的问题是臭名昭著的空指针异常（NullPointerException） —— 每个 Java 程序员都非常了解的异常。
本质上，这是一个包含有可选值的包装类，这意味着 Optional 类既可以含有对象也可以为空。
Optional 是 Java 实现函数式编程的强劲一步，并且帮助在范式中实现。但是 Optional 的意义显然不止于此。
我们从一个简单的用例开始。在 Java 8 之前，任何访问对象方法或属性的调用都可能导致 NullPointerException：

String isocode = user.getAddress().getCountry().getIsocode().toUpperCase();

在这个小示例中，如果我们需要确保不触发异常，就得在访问每一个值之前对其进行明确地检查：

if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        Country country = address.getCountry();
        if (country != null) {
            String isocode = country.getIsocode();
            if (isocode != null) {
                isocode = isocode.toUpperCase();
            }
        }
    }
}

这很容易就变得冗长，难以维护。为了简化这个过程，我们来看看用 Optional 类是怎么做的。从创建和验证实例，到使用其不同的方法，并与其它返回相同类型的方法相结合，下面是见证 Optional 奇迹的时刻。

二、使用Optional优点

Optional 是一个对象容器，具有以下两个特点：

• 提示用户要注意该对象有可能为null
• 简化if else代码

三、Optional使用

1. 创建：

Optional.empty()： 创建一个空的 Optional 实例

//返回一个Null的optional
Optional<String> empty = Optional.empty();

Optional.of(T t)： 创建一个 Optional 实例，当 t为null时抛出异常

//of 方法的值不能为空否则会抛出异常
Optional<String> optional1 = Optional.of("hello");

Optional.ofNullable(T t)： 创建一个 Optional 实例，但当 t为null时不会抛出异常，而是返回一个空的实例

//ofNullable 传入null不会异常
String str = null;
Optional<String> optional2 = Optional.ofNullable(str); 

2. 获取：

get()： 获取optional实例中的对象，当optional 容器为空时报错

3. 判断：

isPresent()： 判断optional是否为空，如果空则返回false，否则返回true

orElse(T other)： 如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个默认值

orElseGet(Supplier other)： 如果optional不为空，则返回optional中的对象；如果为null，则使用Supplier函数生成默认值other

orElseThrow(Supplier exception)： 如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常

4. 过滤：

filter(Predicate p)： 如果optional不为空，则执行断言函数p，如果p的结果为true，则返回原本的optional，否则返回空的optional

5. 映射：

map(Function<T, U> mapper)： 如果optional不为空，则将optional中的对象 t 映射成另外一个对象 u，并将 u 存放到一个新的optional容器中。

flatMap(Function< T,Optional> mapper)： 跟上面一样，在optional不为空的情况下，将对象t映射成另外一个optional

区别： map会自动将u放到optional中，而flatMap则需要手动给u创建一个optional

四、Optional示例

public class OptionalTest {
    public static void main(String[] arg) {
        //1.创建Optional对象，如果参数为空直接抛出异常
        Optional<String> str=Optional.of("a");

        //2.获取Optional中的数据,如果不存在，则抛出异常
        System.out.println(str.get());

        //3.optional中是否存在数据
        System.out.println(str.isPresent());

        //4.获取Optional中的值，如果值不存在，返回参数指定的值
        System.out.println(str.orElse("b"));

        //5.获取Optional中的值，如果值不存在，返回lambda表达式的结果
        System.out.println(str.orElseGet(()->new Date().toString()));

        //6.获取Optional中的值，如果值不存在，抛出指定的异常
        System.out.println(str.orElseThrow(()->new RuntimeException()));



        Optional<String> str2=Optional.ofNullable(null);

        //7.optional中是否存在数据
        System.out.println(str2.isPresent());

        //8.获取Optional中的值，如果值不存在，返回参数指定的值
        System.out.println(str2.orElse("b"));

        //9.获取Optional中的值，如果值不存在，返回lambda表达式的结果
        System.out.println(str2.orElseGet(()->new Date().toString()));

        //10.获取Optional中的值，如果值不存在，抛出指定的异常
        System.out.println(str2.orElseThrow(()->new RuntimeException()));
    }
}

输出：

a
true
a
a
a
false
b
Mon May 15 20:22:47 CST 2022
Exception in thread “main” java.lang.RuntimeException
at OptionalTest.lambda$main$3(OptionalTest.java:42)atOptionalTest$$Lambda$4/931919113.get(Unknown Source)
at java.util.Optional.orElseThrow(Optional.java:290)
at OptionalTest.main(OptionalTest.java:42)

五、Optional示例

package crazy;

import java.util.Optional;

class Company {
    private String name;
    private Optional<Office> office;

    public Company(String name, Optional<Office> office) {
        this.name = name;
        this.office = office;
    }

    public String getName() {
        return name;
    }

    public Optional<Office> getOffice() {
        return office;
    }
}

class Office {
    private String id;
    private Optional<Address> address;

    public Office(String id, Optional<Address> address) {
        this.id = id;
        this.address = address;
    }

    public String getId() {
        return id;
    }

    public Optional<Address> getAddress() {
        return address;
    }
}

class Address {
    private Optional<String> street;
    private Optional<String> city;

    public Address(Optional<String> street, Optional<String> city) {
        this.street = street;
        this.city = city;
    }

    public Optional<String> getStreet() {
        return street;
    }

    public Optional<String> getCity() {
        return city;
    }
}

public class OptionalDemo1 {

    public static void main(String[] args) {
        Optional<Address> address1 = Optional.of(new Address(Optional.ofNullable(null), Optional.of("New York")));
        Optional<Office> office1 = Optional.of(new Office("OF1", address1));
        Optional<Company> company1 = Optional.of(new Company("Door Never Closed", office1));

        // What is the street address of company1?
        // In which city company1 is located?
        Optional<Office> maybeOffice = company1.flatMap(Company::getOffice);
        Optional<Address> maybeAddress = office1.flatMap(Office::getAddress);
        Optional<String> maybeStreet = address1.flatMap(Address::getStreet);

        maybeStreet.ifPresent(System.out::println);
        if (maybeStreet.isPresent()) {
            System.out.println(maybeStreet.get());
        } else {
            System.out.println("Street not found.");
        }

        // shorter way
        String city = company1.flatMap(Company::getOffice)
                .flatMap(Office::getAddress)
                .flatMap(Address::getStreet)
                .orElse("City is not found.");

        System.out.println("City: " + city);

         // only print if city is not null
        company1.flatMap(Company::getOffice)
                .flatMap(Office::getAddress)
                .flatMap(Address::getCity)
                .ifPresent(System.out::println);

    }
}