上一小节，我们接触到了Optional类，但没有详细展开介绍，Optional类也是 Java 8 新加入的类。本小节我们就来学习一下这个类，你将了解到Optional类的解决了什么问题，如何创建Optioanl类的对象，它又有哪些常用方法，如何在实际开发中应用Optional类等内容。

1. Optional 类概述

空指针异常（NullPointerExceptions）是 Java 最常见的异常之一，一直以来都困扰着 Java 程序员。一方面，程序员不得不在代码中写很多null的检查逻辑，让代码看起来非常臃肿；另一方面，由于其属于运行时异常，是非常难以预判的。
为了预防空指针异常，Google的Guava项目率先引入了Optional类，通过使用检查空值的方式来防止代码污染，受到Guava项目的启发，随后在Java 8中也引入了Optional类。
Optional 类位于java.util包下，是一个可以为 null 的容器对象，如果值存在则isPresent()方法会返回 true ，调用 get() 方法会返回该对象，可以有效避免空指针异常。下面我们来学习如何实例化这个类，以及这个类下提供了哪些常用方法。

2. 创建 Optional 对象

查看 java.util.Optional类源码，可以发现其构造方法是私有的，因此不能通过new关键字来实例化：
1.png
我们可以通过如下几种方法，来创建Optional 对象：

  • Optional.of(T t)：创建一个 Optional 对象，参数 t 必须非空；
  • Optional.empty()：创建一个空的Optional实例；
  • Optional.ofNullable(T t)：创建一个Optional对象，参数t 可以为 null。

实例如下：

  1. import java.util.Optional;
  3. public class OptionalDemo1 {
  5.     public static void main(String[] args) {
  6.         // 创建一个 StringBuilder 对象
  7.         StringBuilder string = new StringBuilder("我是一个字符串");
  9.         // 使用 Optional.of(T t) 方法，创建 Optional 对象，注意 T 不能为空：
  10.         Optional<StringBuilder> stringBuilderOptional = Optional.of(string);
  11.         System.out.println(stringBuilderOptional);
  13.         // 使用 Optional.empty() 方法，创建一个空的 Optional 对象：
  14.         Optional<Object> empty = Optional.empty();
  15.         System.out.println(empty);
  17.         // 使用 Optional.ofNullable(T t) 方法，创建 Optional 对象，注意 t 允许为空：
  18.         stringBuilderOptional = null;
  19.         Optional<Optional<StringBuilder>> stringBuilderOptional1 = Optional.ofNullable(stringBuilderOptional);
  20.         System.out.println(stringBuilderOptional1);
  21.     }
  23. }

运行结果：

  1. Optional[我是一个字符串]
  2. Optional.empty
  3. Optional.empty

3. 常用方法

Optional类提供了如下常用方法：

  • booean isPresent()：判断是否包换对象；
  • void ifPresent(Consumer<? super T> consumer)：如果有值，就执行 Consumer 接口的实现代码，并且该值会作为参数传递给它；
  • T get()：如果调用对象包含值，返回该值，否则抛出异常；
  • T orElse(T other)：如果有值则将其返回，否则返回指定的other 对象；
  • T orElseGet(Supplier<? extends T other>)：如果有值则将其返回，否则返回由Supplier接口实现提供的对象；
  • T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。

知道了如何创建Optional对象和常用方法，我们下面结合具体实例来看一下，Optional类是如何避免空指针异常的。
请查看如下实例，其在运行时会发生空指针异常：

  1. import java.util.Optional;
  3. public class OptionalDemo2 {
  5.     static class Category {
  6.         private String name;
  8.         public Category(String name) {
  9.             this.name = name;
  10.         }
  12.         public String getName() {
  13.             return name;
  14.         }
  16.         public void setName(String name) {
  17.             this.name = name;
  18.         }
  20.         @Override
  21.         public String toString() {
  22.             return "Category{" +
  23.                     "name='" + name + '\'' +
  24.                     '}';
  25.         }
  26.     }
  28.     static class Goods {
  29.         private String name;
  31.         private Category category;
  33.         public Goods() {
  35.         }
  37.         public Goods(String name, Category category) {
  38.             this.name = name;
  39.             this.category = category;
  40.         }
  42.         public String getName() {
  43.             return name;
  44.         }
  46.         public void setName(String name) {
  47.             this.name = name;
  48.         }
  50.         public Category getCategory() {
  51.             return category;
  52.         }
  54.         public void setCategory(Category category) {
  55.             this.category = category;
  56.         }
  58.         @Override
  59.         public String toString() {
  60.             return "Good{" +
  61.                     "name='" + name + '\'' +
  62.                     ", category=" + category +
  63.                     '}';
  64.         }
  65.     }
  67.     /**
  68.      * 获取商品的分类名称
  69.      * @param goods 商品
  70.      * @return 分类名称
  71.      */
  72.     static String getGoodsCategoryName(Goods goods) {
  73.         return goods.getCategory().getName();
  74.     }
  76.     public static void main(String[] args) {
  77.         // 实例化一个商品类
  78.         Goods goods = new Goods();
  79.         // 获取商品的分类名称
  80.         String categoryName = getGoodsCategoryName(goods);
  81.         System.out.println(categoryName);
  82.     }
  83. }

运行结果：

  1. Exception in thread "main" java.lang.NullPointerException
  2.     at OptionalDemo2.getGoodsCategoryName(OptionalDemo2.java:73)
  3.     at OptionalDemo2.main(OptionalDemo2.java:80)

实例中，由于在实例化Goods类时，我们没有给其下面的Category类型的属性category赋值，它就为 null，在运行时， null.getName()就会抛出空指针异常。同理，如果goods实例为null，那么null.getCategory()也会抛出空指针异常。
在没有使用Optional类的情况下，想要优化代码，就不得不改写getGoodsCategoryName()方法：

  1. static String getGoodsCategoryName(Goods goods) {
  2.     if (goods != null) {
  3.         Category category = goods.getCategory();
  4.         if (category != null) {
  5.             return category.getName();
  6.         }
  7.     }
  8.     return "该商品无分类";
  9. }

这也就是我们上面说的null检查逻辑代码，此处有两层if嵌套，如果有更深层次的级联属性，就要嵌套更多的层级。
下面我们将Optional类引入实例代码：

  1. import java.util.Optional;
  3. public class OptionalDemo3 {
  5.     static class Category {
  6.         private String name;
  8.         public Category(String name) {
  9.             this.name = name;
  10.         }
  12.         public String getName() {
  13.             return name;
  14.         }
  16.         public void setName(String name) {
  17.             this.name = name;
  18.         }
  20.         @Override
  21.         public String toString() {
  22.             return "Category{" +
  23.                     "name='" + name + '\'' +
  24.                     '}';
  25.         }
  26.     }
  28.     static class Goods {
  29.         private String name;
  31.         private Category category;
  33.         public Goods() {
  35.         }
  37.         public Goods(String name, Category category) {
  38.             this.name = name;
  39.             this.category = category;
  40.         }
  42.         public String getName() {
  43.             return name;
  44.         }
  46.         public void setName(String name) {
  47.             this.name = name;
  48.         }
  50.         public Category getCategory() {
  51.             return category;
  52.         }
  54.         public void setCategory(Category category) {
  55.             this.category = category;
  56.         }
  58.         @Override
  59.         public String toString() {
  60.             return "Good{" +
  61.                     "name='" + name + '\'' +
  62.                     ", category=" + category +
  63.                     '}';
  64.         }
  65.     }
  67.     /**
  68.      * 获取商品的分类名称（使用 Optional 类包装）
  69.      * @param goods 商品
  70.      * @return 分类名称
  71.      */
  72.     static String getGoodsCategoryName(Goods goods) {
  73.         // 将商品实例包装入 Optional 类，创建 Optional<Goods> 对象
  74.         Optional<Goods> goodsOptional = Optional.ofNullable(goods);
  75.         Goods goods1 = goodsOptional.orElse(new Goods("默认商品", new Category("默认分类")));
  76.         // 此时 goods1 一定是非空，不会产生空指针异常
  77.         Category category = goods1.getCategory();
  79.         // 将分类实例包装入 Optional 类，创建 Optional<Category> 对象
  80.         Optional<Category> categoryOptional = Optional.ofNullable(category);
  81.         Category category1 = categoryOptional.orElse(new Category("默认分类"));
  82.         // 此时 category1 一定是非空，不会产生空指针异常
  83.         return category1.getName();
  84.     }
  86.     public static void main(String[] args) {
  87.         // 实例化一个商品类
  88.         Goods goods = null;
  89.         // 获取商品的分类名称
  90.         String categoryName = getGoodsCategoryName(goods);
  91.         System.out.println(categoryName);
  92.     }
  93. }

运行结果：

  1. 默认分类

实例中，我们使用Optional类的 ofNullable（T t）方法分别包装了goods对象及其级联属性category对象，允许对象为空，然后又调用了其ofElse(T t)方法保证了对象一定非空。这样，空指针异常就被我们优雅地规避掉了。

4. 对于空指针异常的改进

Java 14 对于空指针异常有了一些改进，它提供了更明确异常堆栈打印信息，JVM 将精确地确定那个变量是null，不过空指针异常依然无法避免。明确的异常堆栈信息，能够帮助开发者快速定位错误发生的位置。

5. 小结

通过本小节的学习，我们知道了 Optional 类主要用于应对 Java 中的空指针异常，它是一个可以为 null 的容器对象，我们可以通过Optional类下的几个静态方法来创建对象。另外，我们也结合实例介绍了如何使用Optional类来规避空指针异常，实例中还有很多其他没用到的 API，希望大家可以自己研习。