看山聊Java：一文掌握 Java8 的 Optional 的 6 种操作

╰+攻爆jí腚メ 2021-09-25 09:16 382阅读 0赞

![一文掌握 Java8 的 Optional 的 6 种操作][Java8 _ Optional _ 6]

你好，我是看山。

Java8 中引入了一个特别有意思类：`Optional`，一个可以让我们更加轻松的避免 NPE（空指针异常，NullPointException）的工具。

很久很久以前，为了避免 NPE，我们会写很多类似`if (obj != null) {}`的代码，有时候忘记写，就可能出现 NPE，造成线上故障。在 Java 技术栈中，如果谁的代码出现了 NPE，有极大的可能会被笑话，这个异常被很多人认为是低级错误。`Optional`的出现，可以让大家更加轻松的避免因为低级错误被嘲讽的概率。

## 定义示例数据 ##

先定义待操作对象，万能的`Student`类和`Clazz`类（用到了 lombok 和 guava）：

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Clazz { 
        private String id;
        private String name;
    }

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Student { 
        private String id;
        private String name;
        private Clazz clazz;
    }

然后定义一组测试数据：

final Clazz clazz1 = new Clazz("1", "高一一班");
    
    final Student s1 = new Student("1", "张三", clazz1);
    final Student s2 = new Student("2", "李四", null);
    
    final List<Student> students = Lists.newArrayList(s1, s2);
    final List<Student> emptyStudents = Lists.newArrayList();
    final List<Student> nullStudents = null;

## 创建实例：of、ofNullable ##

为了控制生成实例的方式，也是为了收紧空值`Optional`的定义，`Optional`将构造函数定义为`private`。想要创建`Optional`实例，可以借助`of`和`ofNullable`两个方法实现。

这两个方法的区别在于：`of`方法传入的参数不能是`null`的，否则会抛出`NullPointerException`。所以，对于可能是`null`的结果，一定使用`ofNullable`。

代码如下：

Optional.of(students);
    Optional.of(emptyStudents);
    Optional.ofNullable(nullStudents);

`Optional`类中还有一个静态方法：`empty`，这个方法直接返回了内部定义的一个常量`Optional<?> EMPTY = new Optional<>()`，这个常量的`value`是`null`。`ofNullable`方法也是借助了`empty`实现`null`的包装：

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

所以说，对于`null`的`Optional`包装类，指向的都是相同的实例对象，`Optional.empty() == Optional.ofNullable(null)`返回的是`true`。换句话说，空`Optional`是单例的。

> 为了方便描述，下文中对值为`null`的`Optional`统称为“**空`Optional`**”。

## 获取数据：get ##

`Optional`的`get`方法有些坑人，先看下它的源码：

public T get() { 
        if (value == null) { 
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

也就是说，`Optional`值为空时，使用`get`方法将抛出`NoSuchElementException`异常。如果不想抛出异常，或者能够 100%确定不是空`Optional`，或者使用`isPresent`方法判断。

如果能 100%确定不是空`Optional`，那就没有必要使用`Optional`包装，直接返回即可。如果需要使用`isPresent`方法，那就和直接判空没有区别了。所以，无论是第一种情况还是第二种情况，都违背了设计这个类的初衷。

## 值为空判断：isPresent、ifPresent ##

`isPresent`用来判断值是否为空，类似于`obj != null`，`ifPresent`可以传入一个`Consumer`操作，当值不为空的时候，会执行`Consumer`函数。比如：

final Optional<List<Student>> nullValue = Optional.ofNullable(nullStudents);
    
    if (nullValue.isPresent()) { 
        System.out.println("value: " + nullValue.get());
    }

上面的方法等价于：

nullValue.ifPresent(value -> System.out.println("value: " + value));

`isPresent`判断的写法上是不是感觉很熟悉，感觉可以直接写为：

if (nullStudents != null) { 
        System.out.println("value: " + nullStudents);
    }

对于`isPresent`，如果是在自己可控的代码范围内，完全没有必要将值封装之后再判空。对于自己不可控的代码，后续的`filter`或者`map`方法可能比`isPresent`更好用一些。

对于`ifPresent`，在使用的时候会有一些限制，就是必须是非空`Optional`的时候，在会执行传入的`Consumer`函数。

## 值处理：map、flatMap ##

`map`和`flatMap`是对`Optional`的值进行操作的方法，区别在于，`map`会将结果包装到`Optional`中返回，`flatMap`不会。但是两个方法返回值都是`Optional`类型，这也就要求，`flatMap`的方法函数返回值需要是`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));
        }
    }

可以看到，如果`Optional`的值为空，`map`直接返回`Optional.EMPTY`，否则会执行函数结果，并使用`Optional.ofNullable`包装并返回。也即是说，只要类结构允许，我们可以一直`map`下去，就像是扒洋葱，一层一层，直到核心。

比如，我们要获取`s2`所在班级名称，在定义的时候，我们将`s2`的`clazz`属性定义为 null，如果以前需要写为：

String clazzNameOld;
    if (s2 != null && s2.getClazz() != null && s2.getClazz().getName() != null) { 
        clazzNameOld = s2.getClazz().getName();
    } else { 
        clazzNameOld = "DEFAULT_NAME";
    }

现在借助`Optional`可以写为：

final String clazzName = Optional.ofNullable(s2)
            .map(Student::getClazz)
            .map(Clazz::getName)
            .orElse("DEFAULT_NAME");

从代码上似乎没有多大改变，但是如果`Clazz`内部还有类对象。或者，我们在`if`判断的时候，少写一层检查呢？而且，`map`的精巧还在于它的返回值永远是`Optional`，这样，我们可以重复调用`map`方法，而不需要中间被打断，增加各种判空逻辑。

## 值为空的处理：orElse、orElseGet、orElseThrow ##

这几个方法可以与`map`操作结合，一起完成对象操作。当值为空时，`orElse`和`orElseGet`返回默认值，`orElseThrow`抛出指定的异常。

`orElse`和`orElseGet`的区别是，`orElse`方法传入的参数是明确的默认值，`orElseGet`方法传入的参数是获取默认值的函数。如果默认值的构造过程比较复杂，需要经过一系列的运算逻辑，那一定要使用`orElseGet`，因为`orElseGet`是在值为空的时候，才会执行函数，并返回默认值，如果值不为空，则不会执行函数，相比于`orElse`而言，减少了一次构造默认值的过程。

同样以上面的例子：

`orElse`的写法：

final String clazzName = Optional.ofNullable(s2)
            .map(Student::getClazz)
            .map(Clazz::getName)
            .orElse(null);

`orElseGet`的写法：

final String clazzName = Optional.of(s2)
            .map(Student::getClazz)
            .map(Clazz::getName)
            .orElseGet(() -> null);

如果`clazz`属性一定不为空，为空则返回异常，可以使用`orElseThrow`：

final String clazzName = Optional.of(s2)
            .map(Student::getClazz)
            .map(Clazz::getName)
            .orElseThrow(() -> new IllegalArgumentException("clazz属性不合法"));

## 条件过滤：filter ##

`filter`方法提供的是值验证，如果值验证为 true，返回当前值；否则，返回空`Optional`。比如，我们要遍历`students`，找到班级属性为空的，打印学生id：

for (final Student s : students) { 
        Optional.of(s)
                .filter(x -> x.getClazz() == null)
                .ifPresent(x -> System.out.println(x.getId()));
    }

## 其他：equals、hashCode、toString ##

`Optional`重写了这三个方法。因为`Optional`可以认为是包装类，所以还是围绕这被包装的值重写这三个方法。下面给出这三个方法的源码：

public boolean equals(Object obj) { 
        // 同一对象判断
        if (this == obj) { 
            return true;
        }
    
        // 类型判断
        if (!(obj instanceof Optional)) { 
            return false;
        }
    
        Optional<?> other = (Optional<?>) obj;
        // 最终还是值的判断
        return Objects.equals(value, other.value);
    }
    
    public int hashCode() { 
        // 直接返回值的hashCode
        return Objects.hashCode(value);
    }
    
    public String toString() { 
        return value != null
            ? String.format("Optional[%s]", value) // 用到了值的toString结果
            : "Optional.empty";
    }

`equals`方法，`Optional.of(s1).equals(Optional.of(s2))`完全等价于`s1.equals(s2)`。

`hashCode`方法，直接返回的是值的hashCode，如果是空`Optional`，返回的是0。

`toString`方法，为了能够识别是`Optional`，将打印数据包装了一下。如果是空`Optional`，返回的是字符串“Optional.empty”；如果是非空，返回是是“Optional\[值的toString\]”。

## 文末总结 ##

NPE 之所以讨厌，就是只要出现 NPE，我们就能够解决。但是一旦出现，都已经是事后，可能已经出现线上故障。偏偏在 Java 语言中，NPE 又很容易出现。`Optional`提供了模板方法，有效且高效的避免 NPE。

接下来，我们针对上面的使用，总结一下：

1.  `Optional`是一个包装类，且不可变，不可序列化
2.  没有公共构造函数，创建需要使用`of`、`ofNullable`方法
3.  空`Optional`是单例，都是引用`Optional.EMPTY`
4.  想要获取`Optional`的值，可以使用`get`、`orElse`、`orElseGet`、`orElseThrow`

另外，还有一些实践上的建议：

1.  使用`get`方法前，必须使用`isPresent`检查。但是使用`isPresent`前，先思考下是否可以使用`orElse`、`orElseGet`等方法代替实现。
2.  `orElse`和`orElseGet`，优先选择`orElseGet`，这个是惰性计算
3.  `Optional`不要作为参数或者类属性，可以作为返回值
4.  尽量将`map`、`filter`的函数参数抽出去作为单独方法，这样能够保持链式调用

## 推荐阅读 ##

*  [一文掌握 Java8 Stream 中 Collectors 的 24 个操作][Java8 Stream _ Collectors _ 24]
 *  [一文掌握 Java8 的 Optional 的 6 种操作][Java8 _ Optional _ 6 1]

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

你好，我是看山，公众号：看山的小屋，10 年老猿，开源贡献者。游于码界，戏享人生。

个人主页：[https://www.howardliu.cn][https_www.howardliu.cn]  
个人博文：[一文掌握 Java8 的 Optional 的 6 种操作][Java8 _ Optional _ 6 1]  
CSDN 主页：[http://blog.csdn.net/liuxinghao][http_blog.csdn.net_liuxinghao]  
CSDN 博文：[一文掌握 Java8 的 Optional 的 6 种操作][Java8 _ Optional _ 6 2]

![公众号：看山的小屋][21785bb43b333b0ff8efda479e715378.png]

[Java8 _ Optional _ 6]: /images/20210923/a9b24ac11a0a41f8ae8e65786fd65f99.png
[Java8 Stream _ Collectors _ 24]: https://www.howardliu.cn/java-stream-collectors/
[Java8 _ Optional _ 6 1]: https://www.howardliu.cn/java-util-optional/
[https_www.howardliu.cn]: https://www.howardliu.cn
[http_blog.csdn.net_liuxinghao]: http://blog.csdn.net/liuxinghao
[Java8 _ Optional _ 6 2]: https://blog.csdn.net/liuxinghao/article/details/117057756
[21785bb43b333b0ff8efda479e715378.png]: /images/20210923/a513511bb5964db3a8c14106935f1d3c.png