深入JDK中的Optional-京东云开发者社区

**概述**：Optional最早是Google公司Guava中的概念，代表的是可选值。Optional类从Java8版本开始加入豪华套餐，主要为了解决程序中的NPE问题，从而使得更少的显式判空，防止代码污染，另一方面，也使得领域模型中所隐藏的知识，得以显式体现在代码中。Optional类位于java.util包下，对链式编程风格有一定的支持。实际上，Optional更像是一个容器，其中存放的成员变量是一个T类型的value，可值可Null，使用的是Wrapper模式，对value操作进行了包装与设计。本文将从Optional所解决的问题开始，逐层解剖，由浅入深，文中会出现Optioanl方法之间的对比，实践，误用情况分析，优缺点等。与大家一起，对这项Java8中的新特性，进行理解和深入。
## 1、解决的问题
臭名昭著的空指针异常，是每个程序员都会遇到的一种常见异常，任何访问对象的方法与属性的调用，都可能会出现NullPointException，如果要确保不触发异常，我们通常需要进行对象的判空操作。
举个栗子，有一个人（Shopper）进超市购物，可能会用购物车（Trolley）也可能会用其它方式，购物车里可能会有一袋栗子（Chestnut），也可能没有。三者定义的代码如下：
```java
public class Shopper {
  private Trolley trolley;
  public Trolley getTrolley(){
    return trolley;
  }
}
public class Trolley {
  private Chestnut chestnut;
  public Chestnut getChestnut(){
     return chestnut;
  }
}
public class Chestnut {
  private String name;
  public String getName(){
    return name;
  }
}
```
这时想要获得购物车中栗子的名称，像下面这么写，就可能会见到我们的“老朋友”（NPE）
```java
public String result(Shopper shopper){
  return shopper.getTrolley().getChestnut().getName();
}
```
为了能避免出现空指针异常，通常的写法会逐层判空（多层嵌套法），如下
```java
public String result(Shopper shopper) {
        if (shopper != null) {
            Trolley trolley = shopper.getTrolley();
            if (trolley != null) {
                Chestnut chestnut = trolley.getChestnut();
                if (chestnut != null) {
                    return chestnut.getName();
                }
            }
        }
        return "获取失败辽";
    }
```
多层嵌套的方法在对象级联关系比较深的时候会看的眼花缭乱的，尤其是那一层一层的括号😒；另外出错的原因也因为缺乏对应信息而被模糊（例如trolley为空时也只返回了最后的获取失败。当然也可以在每一层增加return，相应的代码有会变得很冗长），所以此时我们也可以用遇空则返回的卫语句进行改写。
```java
public String result(Shopper shopper) {
    if (shopper == null) {
        return "购物者不存在";
    }
    Trolley trolley = shopper.getTrolley();
    if (trolley == null) {
        return "购物车不存在";
    }
    Chestnut chestnut = trolley.getChestnut();
    if (chestnut == null) {
        return "栗子不存在";
    }
    return chestnut.getName();
}

```
为了取一个名字进行了三次显示判空操作，这样的代码当然没有问题，但是优秀的工程师们总是希望能获得更优雅简洁的代码。Optional就提供了一些方法，实现了这样的期望。
```java
public String result(Shopper shopper){
 return Optional.ofNullable(shopper)
 .map(Shopper::getTrolley)
 .map(Trolley::getChestnut)
 .map(Chestnut::getName)
 .orElse("获取失败辽");
}
```
## 2、常用方法
#### 1）获得Optional对象
Optional类中有两个构造方法：带参和不带参的。带参的将传入的参数赋值value，从而构建Optional对象；不带参的用null初始化value构建对象。
```java
private Optional() {}
private Optional(T value) {}
```
但是两者都是私有方法，而实际上Optional的对象都是通过静态工厂模式的方式构建，主要有以下三个函数
```java
public static <T> Optional<T> of(T value) {}
public static <T> Optional<T> ofNullable(T value) {}
public static <T> Optional<T> empty() {}
```
创建一个一定不为空的Optional对象，因为如果传入的参数为空会抛出NPE
```java
Chestnut chestnut = new Chestnut();
Optional<Chestnut> opChest = Optional.of(chestnut);
```
创建一个空的Optional对象
```java
Optional<Chestnut> opChest = Optional.empty();
```
创建一个可空的Optional对象
```java
Chestnut chestnut = null;
Optional<Chestnut> opChest = Optional.ofNullable(chestnut);
```
#### 2）正常使用
正常使用的方法可以被大致分为三种类型，判断类、操作类和取值类
```java
//判断类
public boolean isPresent() {}
//操作类
public void ifPresent(Consumer<? super T> consumer) {}
//取值类
public T get() {}
public T orElse(T other) {}
public T orElseGet(Supplier<? extends T> other) {}
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {}
```
isPresent()方法像一个安全阀，控制着容器中的value值是空还是有值，用法与原本的null != obj的用法相似。当obj有值返回true，为空返回false（即value值存在为真）。但一般实现判断空或不为空的逻辑，使用Optional其他的方法处理会更为常见。如下代码将会打印出没有栗子的悲惨事实。
```java
Optional<Chestnut> opChest = null;
if(opChest.isPresent){
 System.out.println("容器里没有栗子");
}
```
ifPresent()方法是一个操作类的方法，他的参数是一段目标类型为Consumer的函数，当value不为空时，自动执行consumer中的accept()方法（传入时实现），为空则不执行任何操作。比如下面这段代码，我们传入了一段输出value的lamda表达式，打印出了“迁西板栗”。
```java
Optional<Chestnut> opChest = Optional.ofNullable(new Chestnut("迁西板栗"));
opChest.ifPresent(c -> System.out.println(c.getName()));
```
get()方法源码如下，可以看出，get的作用是直接返回容器中的value。但如此粗暴的方法，使用前如果不判空，在value为空时，便会毫不留情地抛出一个异常。
```java
public T get() {
 if (value == null) {
 throw new NoSuchElementException("No value present");
 }
 return value;
}
```
三个orElse方法与get相似，也都属于取值的操作。与get不同之处在于orElse方法不用额外的判空语句，撰写逻辑时比较愉快。三个orElse的相同之处是当value不为空时都会返回value。当为空时，则另有各自的操作：orElse()方法会返回传入的other实例（也可以为Supplier类型的函数）；orElseGet()方法会自动执行Supplier类型实例的get()方法；orElseThrow()方法会抛出一个自定的异常。更具体的差别会在后面的方法对比中描述。
如下面这段代码，展示了在没有栗子的时候，如何吐出“信阳板栗”、“镇安板栗”，以及抛出“抹油栗子”的警告。
```java
Optional<Chestnut> opChest = Optional.empty();
System.out.println(opChest.orElse(new Chestnut("信阳板栗")));
System.out.println(opChest.orElseGet(() -> new Chestnut("镇安板栗")));
try {
 opChest.orElseThrow(() -> new RuntimeException("抹油栗子呀"));
}catch (RuntimeException e){
 System.out.println(e.getMessage());
}
```
#### 3）进阶使用
```java
public Optional<T> filter(Predicate<? super T> predicate) {}
public Optional map(Function<? super T, ? extends U> mapper) {}
public Optional flatMap(Function<? super T, Optional> mapper) {}
```
filter()方法接受谓词为Predicate类型的函数作为参数，如果value值不为空则自动执行predicate的test()方法（传入时实现），来判断是否满足条件，满足则会返回自身Optional，不满足会返回空Optional；如果value值为空，则会返回自身Optional（其实跟空Optional也差不多）。如下代码，第二句中筛选条件“邵店板栗”与opChest中的板栗名不符，没有通过过滤。而第三句的筛选条件与opChest一致，所以最后打印出来的是“宽城板栗”。
```java
Optional<Chestnut> opChest = Optional.ofNullable(new Chestnut("宽城板栗"));
opChest.filter(c -> "邵店板栗".equals(c.getName())).ifPresent(System.out::println);
opChest.filter(c -> "宽城板栗".equals(c.getName())).ifPresent(System.out::println);
```
map()和flatmap()方法传入的都是一个Function类型的函数，map在这里翻译为“映射”，当value值不为空时进行一些处理，返回的值是经过mapper的apply()方法处理后的Optional类型的值，两个方法的结果一致，处理过程中会有差别。如下代码，从opChest中获取了板栗名后，重新new了一个板栗取名“邢台板栗”，并打印出来，两者输出一致，处理形式上有差异，这个在后面的方法对比中会再次说到。
```java
Optional<Chestnut> opChest = Optional.ofNullable(new Chestnut("邢台板栗"));
System.out.println(opChest.map(c -> new Chestnut(c.getName())));
System.out.println(opChest.flatMap(c -> Optional.ofNullable(new Chestnut(c.getName()))));
```
#### 4）1.9新增
```java
public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {}
public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {}
public Stream<T> stream() {}
```
JDK1.9中增加了三个方法：ifPresentOrElse() 、or()和stream()方法。
1.8时，ifPresent()仅提供了if(obj != null)的方法，并未提供if(obj != null)else{}的操作，所以在1.9中增加了一个ifPresentElse()方法，提供了这方面的支持。该方法接收两个参数Consumer和Runnable类型的函数，当value不为空，调用action的accept()方法，这点与ifPresent()一致，当value为空时，会调用emptyAction的run()方法，执行else语义的逻辑。如下面代码，会打印出“木有栗子”的提示。
```java
Optional<Chestnut> opChest = Optional.empty();
opChest.ifPresentElse(c -> System.out.println(c.getName()),c -> System.out.println("木有栗子呀"));
```
or()方法是作为orElse()和orElseGet()方法的改进而出现的，使用方法一致，但后两个方法在执行完成后返回的并非包装值。如果需要执行一些逻辑并返回Optional时，可以使用or()方法。该方法传入Supplier接口的实例，当value有值时直接返回自身Optional，当为空时，自动执行suuplier的get()方法，并包装成Optional返回，其源码中包装的语句如下：
```java
Optional<T> r = (Optional<T>) supplier.get();
return Objects.requireNonNull(r);
```
stream()方法则不用多说，是一个提供给流式编程使用的方法，功能上是一个适配器，将Optional转换成Stream：没有值返回一个空的stream，或者包含一个Optional的stream。其源码如下：
```java
if (!isPresent()) {
 return Stream.empty();
} else {
 return Stream.of(value);
}
```
## 3、方法对比和总结
Optional封装的方法较多，选择一个合适的方法的前提是要了解各自适用的场景和异同
#### 1）创建方法的对比
由于构造器为私有方法，创建对象只能通过静态工厂的方式创建。of()、ofNullable()和empty()方法是三个静态方法。先上源码
```java
//工厂方法
public static <T> Optional<T> of(T value) {
 return new Optional<>(value);
}

public static <T> Optional<T> ofNullable(T value) {
 return value == null ? empty() : of(value);
}

public static<T> Optional<T> empty() {
 @SuppressWarnings("unchecked")
 Optional<T> t = (Optional<T>) EMPTY;
 return t;
}
//构造方法
private Optional() {
 this.value = null;
}
private Optional(T value) {
 this.value = Objects.requireNonNull(value);
}
//静态常量
private static final Optional<?> EMPTY = new Optional<>();
```
of()方法通过调用带参构造，new出一个Optional对象，正常形参带值是不会有问题的，但是当形参为空时，设置value前的Objects.requireNonNull()非空校验，就会抛出一个异常，代码如下：
```java
public static <T> T requireNonNull(T obj) {
 if (obj == null)
 throw new NullPointerException();
 return obj;
}
```
requireNonNull()方法是java.util包下Objects类的一个方法，作用是检查传入的参数是否为空，为空会抛出一个NPE，在Optional类中用到的地方还有很多。所以只有确信构造Optional所传入的参数不为空时才可使用of()方法。
与of()相对的还有一个ofNullable()方法，该方法允许接受null值构造Optional，当形参为null时，调用empty()方法，而empty()方法返回的是一个编译期就确定的常量EMPTY，EMPTY取值是无参构造器创建对象，最终得到的是一个value为空的Optional对象。
#### 2）使用方法的对比
2.2)中说到，正常使用的方法中有属于取值类的方法，orElse()、orElseGet()和orElseThrow()，这三个方法在非空时均返回value，但是为空时的处理各不相同。先上源码：
```java
public T orElse(T other) {
 return value != null ? value : other;
}

public T orElseGet(Supplier<? extends T> other) {
 return value != null ? value : other.get();
}

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
 if (value != null) {
 return value;
 } else {
 throw exceptionSupplier.get();
 }
}
```
orElse()和orElseGet()方法最直观的差异是形参的不同，看下面一段代码：
```java
//测试语句
Optional<Chestnut> opChest = Optional.ofNullable(new Chestnut("桐柏板栗"));
//Optional<Chestnut> opChest = Optional.empty();
opChest.orElse(print("orELse"));
opChest.orElseGet(()->print("orElseGet"));
//调用方法
private static Chestnut print(String method){
 System.out.println("燕山板栗最好吃----"+method);
 return new Chestnut("燕山板栗");
}
```
第一次，new出一个“桐柏板栗”的Optional，分别调用orElse()和orElseGet()方法，结果出现了两行的“燕山板栗最好吃”的输出，因为两个方法在value不为null时都会执行形参中的方法；
第二次，通过empty()方法获得一个空栗子的Optional，再调用orElse()和orElseGet()方法，结果居然还出现了一行“燕山板栗最好吃”的输出。
```java
第一次输出：
燕山板栗最好吃----orELse
燕山板栗最好吃----orElseGet
第二次输出：
燕山板栗最好吃----orELse
```
其原因是orElseGet()的参数是Supplier目标类型的函数，简单来说，Suppiler接口类似Spring的懒加载，声明之后并不会占用内存，只有执行了get()方法之后，才会调用构造方法创建出对象，而orElse()是快加载，即使没有调用，也会实际的运行。
这个特性在一些简单的方法上差距不大，但是当方法是一些执行密集型的调用时，比如远程调用，计算类或者查询类方法时，会损耗一定的性能。
orElseThrow()方法与orElseGet()方法的参数都是Supplier参数都是函数类型的，这意味着这两种方法都是懒加载，但针对于必须要使用异常控制流程的场景，orElseThrow()会更加合适，因为可以控制异常类型，使得相比NPE会有更丰富的语义。
#### 3）其他方法的对比
**a、map与filterMap**
先上源码：
```java
public Optional map(Function<? super T, ? extends U> mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent())
 return empty();
 else {
 return Optional.ofNullable(mapper.apply(value));
 }
}

public Optional flatMap(Function<? super T, Optional> mapper) {
 Objects.requireNonNull(mapper);
 if (!isPresent())
 return empty();
 else {
 return Objects.requireNonNull(mapper.apply(value));
 }
}
```
map()与filterMap()的相同点是，都接受一个Function类型的函数，并且返回值都是Optional类型的数据。但是从源码中我们也能看出：
首先，map()在返回时，使用了ofNullable()函数对返回值包了一层，这个函数在2.1)已经说过，是一个Optional的工厂函数，作用是将一个数据包装成Optional；而filterMap()返回时只是做了非空校验，在应用mapper.apply时就已经是一个Optional类型的对象。
其次，从签名中也可以看出，map()的Function的输出值是"？ extends U"，这意味着在mapper.apply()处理完成后，只要吐出一个U类型或者U类型的子类即可；而filterMap()的Functional的输出值是“Optional”，则在mapper.apply()处理完成之后，返回的必须是一个Optional类型的数据。

**b、ifPresent与ifPresentOrElse**
ifPresentOrElse()方法是作为ifPresent()的改进方法出现的。先看源码：
```java
public void ifPresent(Consumer<? super T> action) {
 if (value != null) {
 action.accept(value);
 }
}
public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
 if (value != null) {
 action.accept(value);
 } else {
 emptyAction.run();
 }
}
```
从源码中可以看出，ifPresentOrElse()参数增加了一个Runnable类型的函数emptyAction，在value != null时，都激活了action.accept()方法。只是当value == null时，ifPresentOrElse()方法还会调用emptyAction.run()方法。所以总的来说，jdk1.9加入ifPresentOrElse()方法，是作为ifPreset在if-else领域的补充出现的。

**c、or与orElse**
同样作为改进的or()方法也是为了解决orElse系列方法的“小缺点”出现的，先看源码：
```java
public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
 Objects.requireNonNull(supplier);
 if (isPresent()) {
 return this;
 } else {
 @SuppressWarnings("unchecked")
 Optional<T> r = (Optional<T>) supplier.get();
 return Objects.requireNonNull(r);
 }
}
public T orElse(T other) {
 return value != null ? value : other;
}
public T orElseGet(Supplier<? extends T> supplier) {
 return value != null ? value : supplier.get();
}
```
or()方法在签名形式上更接近orElseGet()，即形参都是Supplier类型的函数，但是与其不同的是，or()方法在形参中，指定了Supplier返回的类型必须为Optional类型，且value的类型必须为T或者T的子类。orElse系列的方法，更像是一种消费的方法，从一个Optional的实例中“取出“value的值进入下一步操作，而or()方法则像是建造者模式，对value有一定的操作之后，重新吐出的还是Optional类型的数据，所以使用时可以串联在一起，后一个or处理前一个or吐出的Optional。
#### 4）“危险”方法的对比
这里指的“危险”指的是会抛出异常，毕竟引进Optional类的目的就是去除对NPE的判断，如果此时再抛出一个NPE或者其他的异常，没有处理好就会为程序引入不小的麻烦。所以对Optional中可能抛出异常的方法做一个总结。
首先，最直观的会抛出异常的方法就是of()方法，因为of方法会调用带参构造创建实例，而带参构造中有对value非空的检查，如果空会抛出NPE异常；
其次，get()方法也是一个“危险”的方法，因为当不判空直接使用get取值时，会触发get中NoSuchElementException异常；
再次，orElseThrow()方法也会抛出异常，但是这种异常属于人为指定的异常，是为了使得异常情况的语义更加丰富，而人为设置的，是一种可控的异常；
最后，在一些方法中，设置了参数非空检查（Objects.requireNonNull()），这种检查会抛出NPE异常，除去已经提到的带参构造器，还有filter、map、flatMap、or这四个方法，如果传入的接口实例是Null值就会随时引爆NPE。
## 4、误用形式与Best practice
### 1）误用形式
**a、初始化为null**
第一种误用形式是给Optional类型的变量初始化的时候.Optional类型变量是默认不为空的，所以在取方法执行的时候才可以肆无忌惮"点"出去，如果在初始化的时候出现：
```java
Optional<Chestnut> chest = null;
```
并且不及时为chest赋值，则还是容易出现NPE，正确的初始化方式应该是：
```java
Optional<Chestnut> chest = Optional.empty();
```
**b、简单判空**
第二种比较常见的误用形式应该是使用isPresent()做简单判空。原本的代码如下：
```java
public String getName(Chestnut chestnut){
	if(chestnut == null){
		return "栗子不存在";
	}else return chestnut.name();
}
```
代码中，通过检查chestnut == null来处理为空时的情况，简单使用isPresent()方法判空的代码如下：
```java
public String getName(Chestnut chestnut){
	Optional<Chestnut> opChest = Optional.ofNullable(chestnut);
	if(!opChest.isPresent()){
		return "栗子不存在";
	}else return opChest.getname();
}
```
酱婶儿并没有太大差别，所以在使用Optional时，首先应避免使用 Optional.isPresent() 来检查实例是否存在，因为这种方式和 null!= obj 没有区别也没什么意义。

**c、简单get**
第三种比较常见的误用形式是使用Optional.get()方式来获取Optional中value的值，get()方法中对value==null的情况有抛出异常，所以应该在做完非空校验之后再从get取值，或者十分确定value一定不为空，否则会出现NoSuchElementException的异常。相对的，如果不是很确信，则使用orElse()，orElseGet()，orElseThrow()获得你的结果会更加合适。

**d、作为属性字段和方法参数**
第四种误用形式在初学Optional的时候容易碰到，当指定某个类中的属性，或者方法的参数为Optional的时候，idea会给出如下提示：

Reports any uses of java.util.Optional<T>, java.util.OptionalDouble, java.util.OptionalInt, java.util.OptionalLong or com.google.common.base.Optional as the type for a field or parameter. Optional was designed to provide a limited mechanism for library method return types where there needed to be a clear way to represent "no result". Using a field with type java.util.Optional is also problematic if the class needs to be Serializable, which java.util.Optional is not.

大意是不建议如此使用Optional。第一，不建议使用Optional作为字段或参数，其设计是为库方法返回类型提供一种有限的机制，而这种机制可以清晰的表示“没有结果”的语义；第二，Optional没有实现Serilazable，是不可被序列化的。
这种误用方法比较明显，复现和避免也比较简单。但笔者还想就这两个建议的原因做进一步的探究，所以查阅了一些资料，大体的原因如下：
第一个原因，为什么不适合做属性字段和方法参数？直白的说，就是麻烦。为了引入Optional，却需要加入多段样板代码，比如判空操作。使得在不合适的位置使用Optional不仅没有给我们带来便利，反而约束了写代码的逻辑。
写以下域模型代码
```java
public class Chestnut {
 private String firstName;
 private Optional<String> midName = Optional.empty();
 private String lastName;
 public void setMidName(Optional<String> midName) {
 this.midName = midName;
 }
 public String getFullName() {
 String fullName = firstName;
 if(midName != null) {
 if(midName.isPresent()){
 fullName = fullName.concat("." + midName.get());
 }
 return fullName.concat("." + lastName);
 }
 }
}
```
 可见在setter方法中没有对形参做相应的校验，那么则需要在使用的getFullName()方法中，增加对属性midName的判空操作，因为完全可能通过setter方法使得属性为null。如果把判空移到setter方法中，也并没有减少判空，使得平白挤进了一段样板代码。另外在传入方法时，也需要对原本的value包装一层后再传入，使得代码显得累赘了，如下：
```java
chest.setMidName(Optional.empty());
chest.setMidName(Optional.of("阿栗"));
```
在属性不为Optional的时候，如果给属性赋值，需要使用“消费”操作，比如orElse()，取出值再赋给属性，相比直接传入String类型的值作为字段和形参可以减少这些步骤，后者反而更加合适。

第二个原因，为什么没有实现序列化？相关可以参见Java Lamda的专家组讨论。
![](//img1.jcloudcs.com/developer.jdcloud.com/aa7b586d-6e37-4f5b-ab3b-de59a96fc16e20210525140326.png)
JDK在序列化上比较特殊，需要同时兼顾向前和向后兼容，比如在JDK7中序列化的对象应该能够在JDK8中反序列化，反之亦然。并且，序列化依赖于对象的identity保持唯一性。当前Optional是引用类型的，但其被标记为value-based class（基于值的类），并且有计划在今后的某一个JDK版本中实现为value-based class，可见上图。如果被设计为可序列化，就将出现两个矛盾点：1）如果Optional可序列化，就不能将Optional实现为value-based class，而必须是引用类型，2）否则将value-based class加入同一性的敏感操作（包含引用的相等性如:==，同一性的hashcode或者同步等），但是这个与当前已发布的JDK版本都是冲突的。所以综上，考虑到未来JDK的规划和实现的冲突，一开始就将Optional设置为不可序列化的，应该是最合适的方案了。

Value-Based Classes（基于值的类），以下是来自Java doc的解释：

Some classes, such as java.util.Optional and java.time.LocalDateTime, are value-based. Instances of a value-based class:
1、are final and immutable (though may contain references to mutable objects);
2、have implementations of equals, hashCode, and toString which are computed solely from the instance's state and not from its identity or the state of any other object or variable;
3、make no use of identity-sensitive operations such as reference equality (==) between instances, identity hash code of instances, or synchronization on an instances's intrinsic lock;
4、are considered equal solely based on equals(), not based on reference equality (==);
5、do not have accessible constructors, but are instead instantiated through factory methods which make no committment as to the identity of returned instances;
6、are freely substitutable when equal, meaning that interchanging any two instances x and y that are equal according to equals() in any computation or method invocation should produce no visible change in behavior.
 A program may produce unpredictable results if it attempts to distinguish two references to equal values of a value-based class, whether directly via reference equality or indirectly via an appeal to synchronization, identity hashing, serialization, or any other identity-sensitive mechanism. Use of such identity-sensitive operations on instances of value-based classes may have unpredictable effects and should be avoided.
### 2）Best practice
实践中常常组合使用以上各种方法，且很多方法常与Lambda表达式结合，获取想要的结果，这里列出两个常见的使用方式，值类型转换和集合元素过滤。

**a、示例一**
```java
Chestnut chestnut = new Chestnut("锥栗板栗");
if(chestnut != null){
 String chestName = chestnut.getName();
 if(chestName != null){
 return chestName.concat("好好吃！");
 }
}else{
 return null;
}
```
可以简化成：
```java
Chestnut chestnut = new Chestnut("锥栗板栗");
return Optional.ofNullable(chestnut)
 .map(Chestnut::getName)
 .map(name->name.concat("好好吃！"))
 .orElse(null);
```
**b、示例二**
```java
public static void main(String[] args) {
 // 创建一个栗子集合
 List<Chestnut> chestList = new ArrayList<>();
 // 创建几个栗子
 Chestnut chest1 = new Chestnut("abc");
 Chestnut chest2 = new Chestnut("efg");
 Chestnut chest3 = null;
 // 将栗子加入集合
 chestList.add(chest1);
 chestList.add(chest2);
 chestList.add(chest3);
 // 创建用于存储栗子名的集合
 List<String> nameList = new ArrayList();
 // 循环栗子列表获取栗子信息，值获取不为空且栗子名以‘a’开头
 // 如果不符合条件就设置默认值，最后将符合条件的栗子名加入栗子名集合
 for (Chestnut chest : chestList) {
 nameList.add(Optional.ofNullable(chest)
 .map(Chestnut::getName)
 .filter(value -> value.startsWith("a"))
 .orElse("未填写"));
 }
 // 输出栗子名集合中的值
 System.out.println("通过 Optional 过滤的集合输出：");
 nameList.stream().forEach(System.out::println);
}
```
##5、总结
本文首先，从所解决的问题开始，介绍了当前NPE处理所遇到的问题；然后，分类地介绍了Optional类中的方法并给出相应的示例；接着，从源码层面对几个常用的方法进行了对比；最后，列举出了几个常见的误用形式和Best practice，结束了全文。
Optional类具有：可以显式体现值可能为空的语义和隐藏可能存在空指针的不确定性的优点，但是同时也具有，适用范围不是很广（建议使用于返回值和NPE逻辑处理）以及使用时需要更多考量的缺点。
但是总体看来，Optional类是伴随Java8函数式编程出现的一项新特性。为处理逻辑的实现提供了更多的选择，未来期待更多的实践和best practice出现，为Optional带来更多出场的机会。
## 6、参考
[1] https://mp.weixin.qq.com/s/q_WmD3oMvgPhakiPLAq-CQ 来源:wechat
[2] https://www.runoob.com/java/java8-optional-class.html 来源:菜鸟教程
[3] https://blog.csdn.net/qq_40741855/article/details/103251436 来源:CSDN
[4] https://yanbin.blog/java8-optional-several-common-incorrect-usages/#more-8824 来源:blog
[5] https://www.javaspecialists.eu/archive/Issue238-java.util.Optional---Short-Tutorial-by-Example.html 来源:java specialists
[6] Java核心技术 卷II - Java8的流库 - Optional类型
[7] https://www.zhihu.com/question/444199629/answer/1729637041 来源:知乎

如有不当之处，望指正～

------------

###### 自猿其说Tech-JDL京东物流技术发展部
###### 作者：供应链技术部-B2B研发组 历子谦

------------