简介

空指针异常是导致Java应用程序失败的最常见原因。
为了解决空指针异常更加优雅，Java8 提供了 Optional 类库。
Optional 实际上是个容器：它可以保存类型T的值，或者仅仅保存null。
Optional 提供很多有用的方法，这样我们就不用显式进行空值检测。

代码示例

Optional.of() 或者 Optional.ofNullable() ：创建 Optional 对象，差别在于 of 不允
许参数是 null ，而 ofNullable 则无限制。

// 参数不能是null
Optional optional1 = Optional.of(1);
// 参数可以是null
Optional optional2 = Optional.ofNullable(null);
// 参数可以是非null
Optional optional3 = Optional.ofNullable(2);

Optional.empty() ：所有null包装成的 Optional 对象

Optional optional1 = Optional.ofNullable(null);
Optional optional2 = Optional.ofNullable(null);
System.out.println(optional1 == optional2);// true
System.out.println(optional1 == Optional.empty());// true
Object o1 = Optional.empty();
Object o2 = Optional.empty();
System.out.println(o1 == o2);// true

isPresent() ：判断值是否存在

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
// isPresent判断值是否存在
System.out.println(optional1.isPresent() == true);
System.out.println(optional2.isPresent() == false);

ifPresent(Consumer consumer) ：如果option对象保存的值不是null，则调用consumer对象，否则不调用

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
// 如果不是null,调用Consumer
optional1.ifPresent(new Consumer<Integer>() {
@Override
public void accept(Integer t) {
System.out.println("value is " + t);
}
});
// null,不调用Consumer
optional2.ifPresent(new Consumer<Integer>() {
@Override
public void accept(Integer t) {
System.out.println("value is " + t);
}
});

在1.8时期 Optional 类只为我们提供了代替 if(user != null) 的方法，并未提供支持 if (user != null) else { // xxx}的操作，即JDK1.8中 Optional 类 ifPresent 方法没有对else的操作提供支持
在JDK1.9后改进了 Optional 类增加了 ifPresentOrElse 方法,此方法支持了if (user != null) else { // xxx}的操作

public void Test01(User user) {
        if (user != null) {
            user.getName();
            user.getAge();
        } else {
            System.err.println("user 对象为null");
        }
    }
 
    public void Test02(User user) {
        Optional.ofNullable(user).ifPresentOrElse(u -> {
            user.getName();
            user.getAge();
        }, () -> {
            System.err.println("user 对象为null");
        });
    }

orElse(value) ：如果optional对象保存的值不是 null ，则返回原来的值，否则返回 value

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
// orElse
System.out.println(optional1.orElse(1000) == 1);// true
System.out.println(optional2.orElse(1000) == 1000);// true

orElseGet(Supplier supplier) ：功能与 orElse 一样，只不过 orElseGet 参数是一个对象

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
System.out.println(optional1.orElseGet(() -> 1000) == 1);//true
System.out.println(optional2.orElseGet(() -> 1000) == 1000);//true

orElseThrow() ：值不存在则抛出异常，存在则什么不做，有点类似 Guava 的 Precoditions

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
optional1.orElseThrow(() -> {
throw new IllegalStateException();
});
try {
optional2.orElseThrow(() -> {
throw new IllegalStateException();
});
} catch (IllegalStateException e) {
e.printStackTrace();
}

filter(Predicate) ：判断 Optional 对象中保存的值是否满足 Predicate ，并返回新的Optional 。

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
Optional<Integer> filter1 = optional1.filter((a) -> a == null);
Optional<Integer> filter2 = optional1.filter((a) -> a == 1);
Optional<Integer> filter3 = optional2.filter((a) -> a == null);
System.out.println(filter1.isPresent());// false
System.out.println(filter2.isPresent());// true
System.out.println(filter2.get().intValue() == 1);// true
System.out.println(filter3.isPresent());// false

map(Function) ：对 Optional 中保存的值进行函数运算，并返回新的 Optional (可以是任何类型)

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
Optional<String> str1Optional = optional1.map((a) -> "key" + a);
Optional<String> str2Optional = optional2.map((a) -> "key" + a);
System.out.println(str1Optional.get());// key1
System.out.println(str2Optional.isPresent());// false

flatMap() ：功能与 map() 相似，差别请看如下代码。 flatMap 方法与 map 方法类似，区别在于 mapping 函数的返回值不同。 map 方法的 mapping 函数返回值可以是任何类型 T ，而flatMap 方法的 mapping 函数必须是 Optional 。

Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Optional<String>> str1Optional = optional1.map((a) -> Optional.of("key"
+ a));
Optional<String> str2Optional = optional1.flatMap((a) -> Optional.of("key" + a))
;
System.out.println(str1Optional.get().get());// key1
System.out.println(str2Optional.get());// key1

Optional类的方法

方法	描述
empty	返回一个空的 Optional 实例
filter	如果值存在并且满足提供的断言，就返回包含该值的 Optional 对象；否则返回一个空的 Optional 对象
map	如果值存在，就对该值执行提供的mapping 函数调用
flatMap	如果值存在，就对该值执行提供的mapping 函数调用，返回一个Optional 类型的值，否则就返回一个空的 Optional 对象
get	如果该值存在，将该值用 Optional 封装返回，否则抛出一个NoSuchElementException 异常
ifPresent	如果值存在，就执行使用该值的方法调用，否则什么也不做
isPresent	如果值存在就返回 true，否则返回false
of	将指定值用 Optional 封装之后返回，如果该值为 null，则抛出一个NullPointerException 异常
ofNullable	将指定值用 Optional 封装之后返回，如果该值为 null，则返回一个空的Optional 对象
orElse	如果有值则将其返回，否则返回一个默认值
orElseGet	如果有值则将其返回，否则返回一个由指定的 Supplier 接口生成的值
orElseThrow	如果有值则将其返回，否则抛出一个由指定的 Supplier 接口生成的异常