关于java8:京东云开发者｜深入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），也可能没有。三者定义的代码如下：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic 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）

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic String result(Shopper shopper){  return shopper.getTrolley().getChestnut().getName();}

为了能避免出现空指针异样，通常的写法会逐层判空（多层嵌套法），如下

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic 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，相应的代码有会变得很简短），所以此时咱们也能够用遇空则返回的卫语句进行改写。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic 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就提供了一些办法，实现了这样的冀望。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic 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构建对象。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonprivate Optional() {}private Optional(T value) {}

然而两者都是公有办法，而实际上Optional的对象都是通过动态工厂模式的形式构建，次要有以下三个函数

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic static <T> Optional<T> of(T value) {}public static <T> Optional<T> ofNullable(T value) {}public static <T> Optional<T> empty() {}

创立一个肯定不为空的Optional对象，因为如果传入的参数为空会抛出NPE

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonChestnut chestnut = new Chestnut();Optional<Chestnut> opChest = Optional.of(chestnut);

创立一个空的Optional对象

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonOptional<Chestnut> opChest = Optional.empty();

创立一个可空的Optional对象

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonChestnut chestnut = null;Optional<Chestnut> opChest = Optional.ofNullable(chestnut);

2）失常应用

失常应用的办法能够被大抵分为三种类型，判断类、操作类和取值类

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython//判断类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其余的办法解决会更为常见。如下代码将会打印出没有栗子的悲惨事实。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonOptional<Chestnut> opChest = Optional.empty();if (!opChest.isPresent()){  System.out.println("容器里没有栗子");}

ifPresent()办法是一个操作类的办法，他的参数是一段指标类型为Consumer的函数，当value不为空时，主动执行consumer中的accept()办法（传入时实现），为空则不执行任何操作。比方上面这段代码，咱们传入了一段输入value的lamda表达式，打印出了“迁西板栗”。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonOptional<Chestnut> opChest = Optional.ofNullable(new Chestnut("迁西板栗"));opChest.ifPresent(c -> System.out.println(c.getName()));

get()办法源码如下，能够看出，get的作用是间接返回容器中的value。但如此粗犷的办法，应用前如果不判空，在value为空时，便会毫不留情地抛出一个异样。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic 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()办法会抛出一个自定的异样。更具体的差异会在前面的办法比照中形容。

如上面这段代码，展现了在没有栗子的时候，如何吐出“信阳板栗”、“镇安板栗”，以及抛出“抹油栗子”的正告。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonOptional<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）进阶应用

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic Optional<T> filter(Predicate<? super T> predicate) {}public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {}public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {}

filter()办法承受谓词为Predicate类型的函数作为参数，如果value值不为空则主动执行predicate的test()办法（传入时实现），来判断是否满足条件，满足则会返回本身Optional，不满足会返回空Optional；如果value值为空，则会返回本身Optional（其实跟空Optional也差不多）。如下代码，第二句中筛选条件“邵店板栗”与opChest中的板栗名不符，没有通过过滤。而第三句的筛选条件与opChest统一，所以最初打印进去的是“宽城板栗”。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonOptional<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了一个板栗取名“邢台板栗”，并打印进去，两者输入统一，解决模式上有差别，这个在前面的办法比照中会再次说到。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonOptional<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新增

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic 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语义的逻辑。如上面代码，会打印出“木有栗子”的提醒。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonOptional<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返回，其源码中包装的语句如下：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonOptional<T> r = (Optional<T>) supplier.get();return Objects.requireNonNull(r);

stream()办法则不必多说，是一个提供给流式编程应用的办法，性能上是一个适配器，将Optional转换成Stream：没有值返回一个空的stream，或者蕴含一个Optional的stream。其源码如下：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonif (!isPresent()) {  return Stream.empty();} else {  return Stream.of(value);}

3、办法比照和总结

Optional封装的办法较多，抉择一个适合的办法的前提是要理解各自实用的场景和异同

1）创立办法的比照

因为结构器为公有办法，创建对象只能通过动态工厂的形式创立。of()、ofNullable()和empty()办法是三个静态方法。先上源码：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython//工厂办法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()非空校验，就会抛出一个异样，代码如下：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic 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，然而为空时的解决各不相同。先上源码：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPythonpublic 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()办法最直观的差别是形参的不同，看上面一段代码：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython//测试语句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()办法，后果竟然还呈现了一行“燕山板栗最好吃”的输入。

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
第一次输入：
燕山板栗最好吃----orELse
燕山板栗最好吃----orElseGet
第二次输入：
燕山板栗最好吃----orELse

其起因是orElseGet()的参数是Supplier指标类型的函数，简略来说，Suppiler接口相似Spring的懒加载，申明之后并不会占用内存，只有执行了get()办法之后，才会调用构造方法创立出对象，而orElse()是快加载，即便没有调用，也会理论的运行。

这个个性在一些简略的办法上差距不大，然而当办法是一些执行密集型的调用时，比方近程调用，计算类或者查问类办法时，会损耗肯定的性能。

orElseThrow()办法与orElseGet()办法的参数都是函数类型的，这意味着这两种办法都是懒加载，但针对于必须要应用异样管制流程的场景，orElseThrow()会更加适合，因为能够管制异样类型，使得相比NPE会有更丰盛的语义。

3）其余办法的比照

a、map与filterMap

先上源码：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
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()的改良办法呈现的。先看源码：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
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系列办法的“小毛病”呈现的，先看源码：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
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类型变量是默认不为空的，所以在取办法执行的时候才能够胡作非为"点"进来，如果在初始化的时候呈现：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
Optional<Chestnut> chest = null;

并且不及时为chest赋值，则还是容易呈现NPE，正确的初始化形式应该是：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
Optional<Chestnut> chest = Optional.empty();

b、简略判空

第二种比拟常见的误用模式应该是应用isPresent()做简略判空。本来的代码如下：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
public String getName(Chestnut chestnut){

if(chestnut == null){    return "栗子不存在";}else return chestnut.name();

}

代码中，通过查看chestnut == null来解决为空时的状况，简略应用isPresent()办法判空的代码如下：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
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不仅没有给咱们带来便当，反而束缚了写代码的逻辑。

写以下域模型代码

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
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包装一层后再传入，使得代码显得累赘了，如下：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
chest.setMidName(Optional.empty());
chest.setMidName(Optional.of("阿栗"));

在属性不为Optional的时候，如果给属性赋值，须要应用“生产”操作，比方orElse()，取出值再赋给属性，相比间接传入String类型的值作为字段和形参能够缩小这些步骤，后者反而更加适合。

第二个起因，为什么没有实现序列化？相干能够参见Java Lamda的专家组探讨。

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的解释：

Value-based Classes

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、示例一

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
Chestnut chestnut = new Chestnut("锥栗板栗");
if(chestnut != null){
String chestName = chestnut.getName();
if(chestName != null){

return chestName.concat("好好吃！");

}
}else{
return null;
}

能够简化成：

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
Chestnut chestnut = new Chestnut("锥栗板栗");
return Optional.ofNullable(chestnut)

          .map(Chestnut::getName)          .map(name->name.concat("好好吃！"))          .orElse(null);

b、示例二

PlainJavascriptJavaHTML/XMLMarkdownMakefileGoJSONSQLObjective-cYAMLBashPHPPython
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/questio...)https://www.zhihu.com/question/444199629/answer/1729637041 起源:知乎

如有不当之处，望斧正～

作者：历子谦