一、简介
到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。
Optional实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
此处引用java 8实战里面的描述：
在你的代码中始终如一地使用Optional，能非常清晰地界定出变量值的缺失是结构上的问题，还是你算法上的缺陷，抑或是你数据中的问题。另外，我们还想特别强调，引入Optional类的意图并非要消除每一个null引用。与此相反，它的目标是帮助你更好地设计出普适的API，让程序员看到方法签名，就能了解它是否接受一个Optional的值。这种强制会让你更积极地将变量从Optional中解包出来，直面缺失的变量值。
所以，optional的作用是显示的表达变量的状态，而不是为了完全消灭NPE。
二、是否使用Optional对比
2.1 不使用Optional
/**
* 常规实现：根据客户信息获取车辆保险公司的名称
*
* @param person
* @return
*/
public static String getCarInsuranceName(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();
}
以上代码，可能是我日常开发经常遇到的，过多的NullPointerException检查，影响到了代码的可读性以及优雅性，而且存在潜在的风险，假设其中某个环节未做空指针的检查，则会看到我们熟悉而又讨厌的NullPointerException。
2.2 使用Optional
/**
* Optional实现：根据客户信息获取车辆保险公司的名称
*
* @param person
* @return
*/
public static String getCarInsuranceName2(Person person) {
//当Optional对象为空时，则后面的map都不会继续执行
return Optional.ofNullable(person)
.map(Person::getCar)
.map(Car::getInsurance)
.map(Insurance::getName)
.orElse("Unknown");
}
2.3 测试
public static void main(String[] args) {
//测试1
Person person = new Person();
System.out.println(getCarInsuranceName(person));
System.out.println(getCarInsuranceName2(person));
System.out.println("--------------------------");
//测试2
Insurance insurance = new Insurance("xx保险公司");
Car car = new Car(insurance);
Person person2 = new Person(car);
System.out.println(getCarInsuranceName(person2));
System.out.println(getCarInsuranceName2(person2));
}
运行结果
Unknown
Unknown
--------------------------
xx保险公司
xx保险公司
三、Optional的构造方式
为了控制生成实例的方式，也是为了收紧空值Optional的定义，Optional将构造函数定义为private。想要创建Optional实例，可以借助of和ofNullable两个方法实现。这两个方法的区别在于：of方法传入的参数不能是null的，否则会抛出NullPointerException。所以，对于可能是null的结果，一定使用ofNullable。
Optional类中还有一个静态方法：empty，这个方法直接返回了内部定义的一个常量Optional<?> EMPTY = new Optional<>()，这个常量的value是null。ofNullable方法也是借助了empty实现null的包装。所以说，对于null的Optional包装类，指向的都是相同的实例对象，Optional.empty() == Optional.ofNullable(null)返回的是true。换句话说，空Optional是单例的。
3.1 Optional.of(T)
该方式的入参不能为null，否则会有NPE，在确定入参不为空时使用该方式。
3.2 Optional.ofNullable(T)
该方式的入参可以为null，当入参不确定为非null时使用。
3.3 Optional.empty()
这种方式是返回一个空Optional，等效Optional.ofNullable(null)
四、常用函数
4.1 of
为非null的值创建一个Optional。of方法通过工厂方法创建Optional类。需要注意的是，创建对象时传入的参数不能为null。如果传入参数为null，则抛出NullPointerException。因此不经常用。
Optional<Person> personOpt = Optional.of(person);
4.2 ofNullable
为指定的值创建一个Optional，如果指定的值为null，则返回一个空的Optional。
Optional<Person> personOpt = Optional.ofNullable(person);
4.3 isPresent
如果值存在返回true，否则返回false。
public static String getGender(Student student){
Optional<Student> stuOpt = Optional.ofNullable(student);
if(stuOpt.isPresent())
{
return stuOpt.get().getGender();
}
return "Unkown";
}
这种用法不但没有减少null的防御性检查，而且增加了Optional包装的过程，违背了Optional设计的初衷，因此开发中要避免这种糟糕的使用。
4.4 ifPresent
如果Optional实例有值则为其调用consumer，否则不做处理。
public static void printName(Student student){
Optional.ofNullable(student).ifPresent(u -> System.out.println("The student name is : " + u.getName()));
}
4.5 get
如果Optional有值则将其返回，否则抛出NoSuchElementException。因此也不经常用。
4.6 orElse
如果有值则将其返回，否则返回指定的其它值。
public static String getName(Person person) {
return Optional.ofNullable(person).map(Person::getName).orElse("Unknown");
}
4.7 orElseGet
orElseGet与orElse方法类似，区别在于得到的默认值。orElse方法传入的参数是明确的默认值，orElseGet方法传入的参数是获取默认值的函数。
如果默认值的构造过程比较复杂，需要经过一系列的运算逻辑，那一定要使用orElseGet，因为orElseGet是在值为空的时候，才会执行函数，并返回默认值，如果值不为空，则不会执行函数，相比于orElse而言，减少了一次构造默认值的过程。
Optional<Wallet> findByAccountId(Integer accountId);
//为null时，创建一下新的
Wallet wallet = repository.findByAccountId(accountId).orElseGet(() -> {
Wallet newWallet = new Wallet();
Account account = new Account();
account.setId(accountId);
newWallet.setMoney(0D);
newWallet.setAccount(account);
repository.save(newWallet);
return newWallet;
});
4.8 orElseThrow
如果有值则将其返回，否则抛出supplier接口创建的异常。
Account account = Optional.ofNullable(databaseUserRepo.findByUsername(username)).orElseThrow(() -> new UsernameNotFoundException("用户" + username + "不存在"))
4.9 filter
如果有值并且满足断言条件返回包含该值的Optional，否则返回空Optional。
public static void filterAge(Student student){
Optional.ofNullable(student).filter( u -> u.getAge() > 18).ifPresent(u -> System.out.println("The student age is more than 18."));
}
4.10 map
如果有值，则对其执行调用mapping函数得到返回值。如果返回值不为null，则创建包含mapping返回值的Optional作为map方法返回值，否则返回空Optional。
map()方法的源码：
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Optional.ofNullable(mapper.apply(value));
}
}
map()方法的参数为Function（函数式接口）对象，map()方法将Optional中的包装对象用Function函数进行运算，并包装成新的Optional对象（包装对象的类型可能改变）。举例如下：
public static String getCarInsuranceName2(Person person) {
//当Optional对象为空时，则后面的map都不会继续执行
return Optional.ofNullable(person)
.map(Person::getCar)
.map(Car::getInsurance)
.map(Insurance::getName)
.orElse("Unknown");
}
4.11 flatMap
如果有值，为其执行mapping函数返回Optional类型返回值，否则返回空Optional。
flatMap()方法的源码：
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Objects.requireNonNull(mapper.apply(value));
}
}
跟map()方法不同的是，入参Function函数的返回值类型为Optional<U>类型，而不是U类型，这样flatMap()能将一个二维的Optional对象映射成一个一维的对象，faltMap()改写如下：
public static String getCarInsuranceName3(Person person) {
//当Optional对象为空时，则后面的flatMap都不会继续执行
return Optional.ofNullable(person)
.flatMap(e -> Optional.ofNullable(e.getCar()))
.flatMap(c -> Optional.ofNullable(c.getInsurance()))
.map(Insurance::getName)
.orElse("Unknown");
}
map和flatMap是对Optional的值进行操作的方法，区别在于，map会将结果包装到Optional中返回，flatMap不会。但是两个方法返回值都是Optional类型，这也就要求，flatMap的方法函数返回值需要是Optional类型。
4.12 其他：equals、hashCode、toString
Optional重写了这三个方法。因为Optional可以认为是包装类，所以还是围绕这被包装的值重写这三个方法。
equals方法，
Optional.of(s1).equals(Optional.of(s2))完全等价于s1.equals(s2)。hashCode方法，直接返回的是值的hashCode，如果是空Optional，返回的是0。
toString方法，为了能够识别是Optional，将打印数据包装了一下。如果是空Optional，返回的是字符串“Optional.empty”；如果是非空，返回是是“Optional[值的toString]”。
五、正确使用Optional
5.1 尽量避免使用的地方
1、避免使用Optional.isPresent()来检查实例是否存在，因为这种方式和null != obj没有区别，这样用就没什么意义了。
2、避免使用Optional.get()方式来获取实例对象，因为使用前需要使用Optional.isPresent()来检查实例是否存在，否则会出现NPE问题。
3、避免使用Optional作为类或者实例的属性，而应该在返回值中用来包装返回实例对象。
4、避免使用Optional作为方法的参数，原因同3。
5.2 示例
使用Optional，我们就可以把下面这样的代码进行改写
public static String getName(Person person) {
if (person == null) {
return "Unknown";
}
return person.getName();
}
不过，千万不要改写成这副样子
public static String getName(Person person) {
Optional<Person> personOpt = Optional.ofNullable(person);
if (!personOpt.isPresent()) {
return "Unknown";
}
return person.getName();
}
这样改写非但不简洁，而且其操作还是和第一段代码一样。无非就是用isPresent方法来替代u==null。这样的改写并不是Optional正确的用法，我们再来改写一次。
public static String getName(Person person) {
return Optional.ofNullable(person).map(Person::getName).orElse("Unknown");
}
这样才是正确使用Optional的姿势。那么按照这种思路，我们可以安心的进行链式调用，而不是一层层判断了。
