Optional实战与源码分析

- 日理万妓 2023-03-13 06:48 5阅读 0赞

**目录**

一、Optional简述与使用建议

二、API基本功能一览（相关源码见四）

三、实战使用

1.场景：对对象单个属性取值

2.场景：对对象非空进行操作

3.场景：对应信息为空时抛出对应异常

4.场景：对应内容既有过滤又有其他判空操作，针对判空有不同操作处理方式

5.针对集合结合stream进行处理

四、源码分析

1.Optional(T value),empty(),of(T value),ofNullable(T value)

2.orElse(T other)，orElseGet(Supplier other)和orElseThrow(Supplier exceptionSupplier)

3.map(Function mapper)和flatMap(Function> mapper)

4.isPresent()和ifPresent(Consumer consumer)

5.filter(Predicate predicate)

五、Java9功能增强说明

参考文档

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

# 一、Optional简述与使用建议 #

简单来讲，Java 8 引入的新特性*Optional*类，主要解决空指针异常（NullPointerException）问题。从实际使用来看，Optional对多层判空嵌套有奇效，但如果只是简单的单层判空，确实没有必要去引入Optional。

回归正题，Optional<T>类是一个容器类，代表一个值存在和不存在，原来用不惯null表示一个值的不存在，现在用Optional可以更好的表达这个概念，它是 Java 实现函数式编程的强劲一步，并且帮助在范式中实现。

重要的一点是***Optional*** **不是** ***Serializable***。因此，它不应该用作类的字段。如果你需要序列化的对象包含 *Optional* 值，[*Jackson* 库][Jackson_]支持把 *Optional* 当作普通对象。也就是说，*Jackson* 会把空对象看作 *null*，而有值的对象则把其值看作对应域的值，这个功能在 [jackson-modules-java8][] 项目中。

# 二、API基本功能一览（相关源码见四） #

相关API基本功能如下表记录，其对应的源码分析在后面分析：

<table> 
 <tbody> 
 <tr> 
 <td style="width:106px;">基本功能分类</td> 
 <td style="width:192px;">具体方法</td> 
 <td style="width:428px;">功能讲解</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="width:106px;">创建</td> 
 <td style="width:192px;">Optional.empty()</td> 
 <td style="width:428px;">创建一个空的 Optional 实例</td> 
 </tr> 
 <tr> 
 <td style="width:192px;">Optional.of(T t)</td> 
 <td style="width:428px;">创建一个 Optional 实例，当 t为null时抛出异常&nbsp;</td> 
 </tr> 
 <tr> 
 <td style="width:192px;">Optional.ofNullable(T t)</td> 
 <td style="width:428px;">创建一个 Optional 实例，但当 t为null时不会抛出异常，而是返回一个空的实例</td> 
 </tr> 
 <tr> 
 <td style="width:106px;">获取</td> 
 <td style="width:192px;">&nbsp;get()</td> 
 <td style="width:428px;">获取optional实例中的对象，当optional 容器为空时报错</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="width:106px;">判断</td> 
 <td style="width:192px;">isPresent()</td> 
 <td style="width:428px;">判断optional是否为空，如果空则返回false，否则返回true</td> 
 </tr> 
 <tr> 
 <td style="width:192px;">ifPresent(Consumer c)</td> 
 <td style="width:428px;">如果optional不为空，则将optional中的对象传给Comsumer函数</td> 
 </tr> 
 <tr> 
 <td style="width:192px;">orElse(T other)</td> 
 <td style="width:428px;">如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个默认值</td> 
 </tr> 
 <tr> 
 <td style="width:192px;">orElseGet(Supplier&lt;T&gt; other)</td> 
 <td style="width:428px;">如果optional不为空，则返回optional中的对象；如果为null，则使用Supplier函数生成默认值other</td> 
 </tr> 
 <tr> 
 <td style="width:192px;">orElseThrow(Supplier&lt;X&gt; exception)</td> 
 <td style="width:428px;">如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常</td> 
 </tr> 
 <tr> 
 <td style="width:106px;">过滤</td> 
 <td style="width:192px;">filter(Predicate&lt;T&gt; p)</td> 
 <td style="width:428px;">如果optional不为空，则执行断言函数p，如果p的结果为true，则返回原本的optional，否则返回空的optional</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="width:106px;">映射</td> 
 <td style="width:192px;">map(Function&lt;T, U&gt; mapper)</td> 
 <td style="width:428px;">如果optional不为空，则将optional中的对象 t 映射成另外一个对象 u，并将 u 存放到一个新的optional容器中</td> 
 </tr> 
 <tr> 
 <td style="width:192px;">flatMap(Function&lt; T,Optional&lt;U&gt;&gt; mapper)</td> 
 <td style="width:428px;"> 跟上面一样，在optional不为空的情况下，将对象t映射成另外一个optional &nbsp;&nbsp;&nbsp;&nbsp;区别：map会自动将u放到optional中，而flatMap则需要手动给u创建一个opt </td> 
 </tr> 
 </tbody> 
</table>

# 三、实战使用 #

### 1.场景：对对象单个属性取值 ###

String s = Optional.ofNullable(user)
                       .map(o -> o.getUsername())
                       .orElseGet(() -> { return "李四";});

用法说明：Optional.ofNullable(user)是判断user是否为null，如果为null，则不会执行map(o -> o.getUsername())，直接执行orElseGet(() -> \{ return “李四”;\})方法。如果不为null，则只执行map(o -> o.getName())方法。  
还有一个跟orElseGet()类似的方法：orElse()，orElse()方法不管ofNullable()值是否为null，都会执行orElse()的代码，而orElseGet()方法只有在ofNullable()值为null时才会执行传入的函数。

### 2.场景：对对象非空进行操作 ###

Optional.ofNullable(user)
        .ifPresent(u->{
            dosomething(u);
    });

用法说明：Optional.ofNullable(user)是判断user是否为null，如果为null，则不会执行后续操作。如果不为null，则只执行后续操作。

### 3.场景：对应信息为空时抛出对应异常 ###

public static String getChampionName(Competition comp) throws IllegalArgumentException {
        return Optional.ofNullable(comp)
                .map(c->c.getResult())
                .map(r->r.getChampion())
                .map(u->u.getName())
                .orElseThrow(()->new IllegalArgumentException("The value of param comp isn't available."));
    }

用法说明：Optional.ofNullable(comp)是判断comp是否为null，如果为null或内部迭代属性有为null的情况，则抛出指定的异常。如果不为null，则按指定的转换进行返回。

### 4.场景：对应内容既有过滤又有其他判空操作，针对判空有不同操作处理方式 ###

if (user != null) {
                int age = user.getAge();
                if (age > 18) {
                    String name = user.getName();
                    if (name != null) {
                        System.out.println(name);
                    } else {
                        System.out.println("Unknown");
                    }
                }
            }
     
     
            //改造后
            Optional.ofNullable(user)
                    .filter(u -> u.getAge() > 18)
                    .map(User::getName)
                    .map(String::toUpperCase)
                    .or(() -> Optional.of("Unknown"))
                    .ifPresent(System.out::println);

用法说明：当用户的年龄大于18岁时，输出一个其大写形式的姓名，当姓名不存在时，输出Unknown

### 5.针对集合结合stream进行处理 ###

/*查询年龄最大的人*/
 Optional<User> max = users.stream().max(Comparator.comparing(User::getAge));
 log.info("maxAge: " + max.get().toString());
 
 /*名字最长的人*/
 Optional<String> max2 = users.stream().map(u -> u.getName()).max(Comparator.comparing(String::length));
 log.info("maxStringLength: " + max2.get());

用法说明：使用Comparator.comparing对集合内信息进行比较得到需要的信息，然后进行get方法将其取出来。

# 四、源码分析 #

### 1.Optional(T value),empty(),of(T value),ofNullable(T value) ###

`Optional(T value)`，即构造函数，它是private权限的，不能由外部调用的。其余三个函数是public权限，供我们所调用。那么，Optional的本质，就是内部储存了一个真实的值，在构造的时候，就直接判断其值是否为空。好吧，这么说还是比较抽象。直接上`Optional(T value)`构造函数的源码，如下图所示:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9mZW5nMTAzMzAxMTE_size_16_color_FFFFFF_t_70][]

查看of(T value)函数源码如下，内部调用了构造函数：

public static <T> Optional<T> of(T value) {
 return new Optional<>(value);
 }

根据构造函数的源码我们可以得出两个结论:

*  通过`of(T value)`函数所构造出的Optional对象，当Value值为空时，依然会报NullPointerException。
 *  通过`of(T value)`函数所构造出的Optional对象，当Value值不为空时，能正常构造Optional对象。

除此之外呢，Optional类内部还维护一个value为null的对象，大概就是长下面这样的：

public final class Optional<T> {
 //省略....
 private static final Optional<?> EMPTY = new Optional<>();
 private Optional() {
 this.value = null;
 }
 //省略...
 public static<T> Optional<T> empty() {
 @SuppressWarnings("unchecked")
 Optional<T> t = (Optional<T>) EMPTY;
 return t;
 }
 }

`empty（）`的作用就是返回EMPTY对象，在此不在分析。

查看ofNullable(T value)源码（平时开发中使用最多的方法）：

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

相比较`of(T value)`的区别就是，当value值为null时，of(T value)会报NullPointerException异常；`ofNullable(T value)`不会throw Exception，`ofNullable(T value)`直接返回一个`EMPTY`对象。

### 2.orElse(T other)，orElseGet(Supplier<? extends T> other)和orElseThrow(Supplier<? extends X> exceptionSupplier) ###

都是在构造函数传入的value值为null时进行调用的。`orElse`和`orElseGet`的用法如下所示，相当于value值为null时，给予一个默认值:

@Test
    public void test() {
        User user = null;
        user = Optional.ofNullable(user).orElse(createUser());
        user = Optional.ofNullable(user).orElseGet(() -> createUser());
        
    }
    public User createUser(){
        User user = new User();
        user.setName("zhangsan");
        return user;

这两个函数的区别：当user值不为null时，`orElse`函数依然会执行createUser()方法，而`orElseGet`函数并不会执行createUser()方法，大家可自行测试。

至于orElseThrow，就是value值为null时,直接抛一个异常出去，用法如下所示：

User user = null;
    Optional.ofNullable(user).orElseThrow(()->new Exception("用户不存在"));

### 3.map(Function<? super T, ? extends U> mapper)和flatMap(Function<? super T, Optional> mapper) ###

这两个函数做的是转换值的操作

public final class Optional<T> {
 //省略....
 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));
 }
 }
 }

在函数体上没什么区别。唯一区别的就是入参，在具体用法上，如果User结构是下面这样的：

public class User {
        private String name;
        public String getName() {
            return name;
        }

对于map而言，这时候取name的写法如下所示：

String city = Optional.ofNullable(user).map(u-> u.getName()).get();

如果User结构是下面这样的：

public class User {
 private String name;
 public Optional<String> getName() {
 return Optional.ofNullable(name);
 }
 }

对于flatMap而言，这时候取name的写法如下所示：

String city = Optional.ofNullable(user).flatMap(u-> u.getName()).get();

### 4.isPresent()和ifPresent(Consumer<? super T> consumer) ###

`isPresent`即判断value值是否为空，而`ifPresent`就是在value值不为空时，做一些操作。这两个函数的源码如下

public final class Optional<T> {
 //省略....
 public boolean isPresent() {
 return value != null;
 }
 //省略...
 public void ifPresent(Consumer<? super T> consumer) {
 if (value != null)
 consumer.accept(value);
 }
 }

需要额外说明的是，大家千万不要把以下方式一改写成方式二，因为这样写，代码结构依然丑陋。

方式一：

if (user != null){
       // TODO: do something
    }

方式二：

User user = Optional.ofNullable(user);
    if (Optional.isPresent()){
       // TODO: do something
    }

### 5.filter(Predicate<? super T> predicate) ###

filter 方法接受一个 `Predicate` 来对 `Optional` 中包含的值进行过滤，如果包含的值满足条件，那么还是返回这个 Optional；否则返回 `Optional.empty。源码如下：`

public final class Optional<T> {
 //省略....
 Objects.requireNonNull(predicate);
 if (!isPresent())
 return this;
 else
 return predicate.test(value) ? this : empty();
 }

`对应使用如下，`如果user的name的长度是小于6的，则返回。如果是大于6的，则返回一个EMPTY对象：

Optional<User> user1 = Optional.ofNullable(user).filter(u -> u.getName().length()<6);

# 五、Java9功能增强说明 #

**Java 9 为 Optional 类添加了三个方法：*or()*、*ifPresentOrElse()* 和 *stream()*。**

*or()* 方法与 *orElse()* 和 *orElseGet()* 类似，它们都在对象为空的时候提供了替代情况。*or()* 的返回值是由 *Supplier* 参数产生的另一个 *Optional* 对象。

如果对象包含值，则 Lambda 表达式不会执行：

@Test
    public void whenEmptyOptional_thenGetValueFromOr() {
        User result = Optional.ofNullable(user)
          .or( () -> Optional.of(new User("default","1234"))).get();
    
        assertEquals(result.getEmail(), "default");
    }

上面的示例中，如果 *user* 变量是 null，它会返回一个 *Optional*，它所包含的 *User* 对象，其电子邮件为 “default”。

*ifPresentOrElse()* 方法需要两个参数：一个 *Consumer* 和一个 *Runnable*。如果对象包含值，会执行 *Consumer* 的动作，否则运行 *Runnable*。

如果你想在有值的时候执行某个动作，或者只是跟踪是否定义了某个值，那么这个方法非常有用：

Optional.ofNullable(user).ifPresentOrElse( u -> logger.info("User is:" + u.getEmail()),
      () -> logger.info("User not found"));

最后介绍的是新的 *stream()* 方法，它**通过把实例转换为 *Stream*** **对象，**让你从广大的 *Stream* API 中受益。如果没有值，它会得到空的 *Stream*；有值的情况下，*Stream* 则会包含单一值。

我们来看一个把 *Optional* 处理成 *Stream* 的例子：

@Test
 public void whenGetStream_thenOk() {
 User user = new User("john@gmail.com", "1234");
 List<String> emails = Optional.ofNullable(user)
 .stream()
 .filter(u -> u.getEmail() != null && u.getEmail().contains("@"))
 .map( u -> u.getEmail())
 .collect(Collectors.toList());
 
 assertTrue(emails.size() == 1);
 assertEquals(emails.get(0), user.getEmail());
 }

这里对 *Stream* 的使用带来了其 *filter()、map()* 和 *collect()* 接口，以获取 *List*。

# 参考文档 #

1.[https://www.cnblogs.com/gongxr/p/14476510.html][https_www.cnblogs.com_gongxr_p_14476510.html]

2.[https://blog.csdn.net/renfujun2012/article/details/108713864][https_blog.csdn.net_renfujun2012_article_details_108713864]

3.[https://blog.csdn.net/Carrots\_vegetables/article/details/109289415][https_blog.csdn.net_Carrots_vegetables_article_details_109289415]

4.[https://blog.csdn.net/caox\_nazi/article/details/85243481][https_blog.csdn.net_caox_nazi_article_details_85243481]

5.[https://blog.csdn.net/weixin\_39851918/article/details/110746202][https_blog.csdn.net_weixin_39851918_article_details_110746202]

6.[https://blog.csdn.net/luckykapok918/article/details/106239526][https_blog.csdn.net_luckykapok918_article_details_106239526]

7.[https://blog.csdn.net/u012954706/article/details/82762784][https_blog.csdn.net_u012954706_article_details_82762784]

8.[https://www.jianshu.com/p/58b3f09a3429][https_www.jianshu.com_p_58b3f09a3429]

9.[https://www.cnblogs.com/zhangboyu/p/7580262.html][https_www.cnblogs.com_zhangboyu_p_7580262.html]

[Jackson_]: https://stackify.com/java-xml-jackson/
[jackson-modules-java8]: https://github.com/FasterXML/jackson-modules-java8
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9mZW5nMTAzMzAxMTE_size_16_color_FFFFFF_t_70]: /images/20230312/b9163e2ca4fd43d9ba26c3f420ef39aa.png
[https_www.cnblogs.com_gongxr_p_14476510.html]: https://www.cnblogs.com/gongxr/p/14476510.html
[https_blog.csdn.net_renfujun2012_article_details_108713864]: https://blog.csdn.net/renfujun2012/article/details/108713864?utm_term=optional%E7%94%A8%E6%B3%95&utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~sobaiduweb~default-9-108713864&spm=3001.4430
[https_blog.csdn.net_Carrots_vegetables_article_details_109289415]: https://blog.csdn.net/Carrots_vegetables/article/details/109289415?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~aggregatepage~first_rank_v2~rank_aggregation-1-109289415.pc_agg_rank_aggregation&utm_term=optional%E7%94%A8%E6%B3%95&spm=1000.2123.3001.4430
[https_blog.csdn.net_caox_nazi_article_details_85243481]: https://blog.csdn.net/caox_nazi/article/details/85243481?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~aggregatepage~first_rank_v2~rank_aggregation-3-85243481.pc_agg_rank_aggregation&utm_term=optional%E7%94%A8%E6%B3%95&spm=1000.2123.3001.4430
[https_blog.csdn.net_weixin_39851918_article_details_110746202]: https://blog.csdn.net/weixin_39851918/article/details/110746202?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~aggregatepage~first_rank_v2~rank_aggregation-14-110746202.pc_agg_rank_aggregation&utm_term=optional%E7%94%A8%E6%B3%95&spm=1000.2123.3001.4430
[https_blog.csdn.net_luckykapok918_article_details_106239526]: https://blog.csdn.net/luckykapok918/article/details/106239526
[https_blog.csdn.net_u012954706_article_details_82762784]: https://blog.csdn.net/u012954706/article/details/82762784?utm_term=optional%E7%94%A8%E6%B3%95&utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~sobaiduweb~default-6-82762784&spm=3001.4430
[https_www.jianshu.com_p_58b3f09a3429]: https://www.jianshu.com/p/58b3f09a3429
[https_www.cnblogs.com_zhangboyu_p_7580262.html]: https://www.cnblogs.com/zhangboyu/p/7580262.html