Optional源码解析与实践

1 导读

NullPointerException在开发过程中经常遇到，稍有不慎小BUG就出现了，如果避免这个问题呢，Optional就是专门解决这个问题的类，那么Optional如何使用呢？让我们一起探索一下吧！

2 源码解析

2.1 Optional定义

Optional类是Java8为了解决null值判断问题而创建的容器类，在java.util 下,使用Optional类可以避免显式的null值判断，避免null导致的NullPointerException。首先，Optional是一个容器，它可以保存类型T的值，也可以为null的容器对象。Optional容器只能存一个值。

2.2 Optional的属性

1）源码：

1/**
2 * Common instance for {@code empty()}.
3 */
4private static final Optional<?> EMPTY = new Optional<>();
5 
6 
7/**
8 * If non-null, the value; if null, indicates no value is present
9 */
10private final T value;

根据源码可以看到Optional有两个属性，一个是为空值准备的EMPTY和泛型值value;

2.3 Optional的方法

Optional除toString()、hashCode() 、equals()等Object的方法外，还包含以下方法。

2.3.1 私有构造方法

1/**
2 * Constructs an empty instance.
3 *
4 * @implNote Generally only one empty instance, {@link Optional#EMPTY},
5 * should exist per VM.
6 */
7private Optional() {
8    this.value = null;
9}
10 
11 
12/**
13* Constructs an instance with the value present.
14*
15* @param value the non-null value to be present
16* @throws NullPointerException if value is null
17*/
18private Optional(T value) {
19    this.value = Objects.requireNonNull(value);
20}

分别是创建一个空实例和构造一个具有当前值的实例。

2.3.2 创建方法 1）源码

1
2public static<T> Optional<T> empty() {
3    @SuppressWarnings("unchecked")
4    Optional<T> t = (Optional<T>) EMPTY;
5    return t;
6}
7public static <T> Optional<T> of(T value) {
8     return new Optional<>(value);
9}
10public static <T> Optional<T> ofNullable(T value) {
11     return value == null ? empty() : of(value);
12}

2）方法说明

empty(）: 创建一个空的 Optional 实例
of(T t) : 创建一个 Optional 实例，当 t为null时抛出异常
ofNullable(T t): 创建一个 Optional 实例，但当 t为null时不会抛出异常，而是返回一个空的实例

3）测试代码

1
2public static void main(String[] args) {
3    Integer value1 = null;
4    Integer value2 = 1;
5    try {
6        Optional<Integer> optional1 = Optional.empty();
7        System.out.println("optional1创建了");
8    }catch (Exception e){
9        System.out.println("optional1失败了");
10    }
11    try {
12        Optional<Integer> optional2 = Optional.of(value1);
13        System.out.println("optional2创建了");
14    }catch (Exception e){
15        System.out.println("optional2失败了");
16    }
17    try {
18        Optional<Integer> optional3 = Optional.ofNullable(value1);
19        System.out.println("optional3创建了");
20    }catch (Exception e){
21        System.out.println("optional3失败了");
22    }
23    try {
24        Optional<Integer> optional4 = Optional.of(value2);
25        System.out.println("optional4创建了");
26    }catch (Exception e){
27        System.out.println("optional4失败了");
28    }
29    try {
30        Optional<Integer> optional5 = Optional.ofNullable(value2);
31        System.out.println("optional5创建了");
32    }catch (Exception e){
33        System.out.println("optional5失败了");
34    }
35}
36

4）运行结果在这里插入图片描述

2.3.3 值获取方法 1）源码

1
2public T get() {
3    if (value == null) {
4        throw new NoSuchElementException("No value present");
5    }
6    return value;
7}

2）方法说明

get(): 如果Optional不为空，则返回该Optional容器中的值，否则抛出NoSuchElementExceptio 。

3）测试代码

1
2public static void main(String[] args) {
3    Integer value1 = null;
4    Integer value2 = 1;
5    Optional<Integer> optional1 = Optional.ofNullable(value1);
6    Optional<Integer> optional2 = Optional.of(value2);
7    try {
8        Integer result=optional1.get();
9        System.out.println("optional1的值是："+result);
10    }catch (Exception e){
11        System.out.println("optional1的值获取失败,原因:"+e.getMessage());
12    }
13    try {
14        Integer result=optional2.get();
15        System.out.println("optional2的值是："+result);
16    }catch (Exception e){
17        System.out.println("optional2的值获取失败,原因:"+e.getMessage());
18    }
19}
20

4）运行结果在这里插入图片描述

2.3.4 判断方法 1）源码

1
2public boolean isPresent() {
3    return value != null;
4}
5public void ifPresent(Consumer<? super T> consumer) {
6    if (value != null)
7        consumer.accept(value);
8}
9public T orElse(T other) {
10    return value != null ? value : other;
11 }   
12public T orElseGet(Supplier<? extends T> other) {
13     return value != null ? value : other.get();
14}
15public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
16   if (value != null) {
17      return value;
18   } else {
19      throw exceptionSupplier.get();
20   }
21}
22

2）方法说明

isPresent(): 判断optional是否为空，如果空则返回false，否则返回true
ifPresent(Consumer c): 如果optional不为空，则将optional中的对象传给Comsumer函数
orElse(T other): 如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个对象。
orElseGet(Supplier other): 如果optional不为空，则返回optional中的对象；如果为null，否则调用其他函数并返回调用的结果
orElseThrow(Supplier exception): 如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常

3）测试代码

1
2public static void main(String[] args) {
3    Integer value1 = null;
4    Integer value2 = 1;
5    Optional<Integer> optional1 = Optional.ofNullable(value1);
6    Optional<Integer> optional2 = Optional.of(value2);
7    try {
8        if(optional1.isPresent()){
9            System.out.println("optional1的isPresent结果不为空");
10        }else{
11            System.out.println("optional1的isPresent结果为空");
12        }
13    }catch (Exception e){
14        System.out.println("optional1的isPresent判空失败,原因:"+e.getMessage());
15    }
16    try {
17        if(optional2.isPresent()){
18            System.out.println("optional2的isPresent结果不为空");
19        }else{
20            System.out.println("optional2的isPresent结果为空");
21        }
22    }catch (Exception e){
23        System.out.println("optional2的isPresent判空失败,原因:"+e.getMessage());
24    }
25 
26 
27    optional1.ifPresent(t->{
28        int i =t+1;
29        System.out.println("optional1处理后的值是"+i);
30    });
31    optional2.ifPresent(t->{
32        int i =t+1;
33        System.out.println("optional2处理后的值是"+i);});
34 
35 
36    Integer value3 = 2;
37    Integer result = optional1.orElse(value3);
38    System.out.println("optional1执行orElse处理后的值是"+result);
39 
40 
41    result = optional2.orElse(value3);
42    System.out.println("optional2执行orElse处理后的值是"+result);
43 
44 
45    result = optional1.orElseGet(()-> new Integer(-1));
46    System.out.println("optional1执行orElseGet处理后的值是"+result);
47 
48 
49    result = optional2.orElseGet(()-> new Integer(-1));
50    System.out.println("optional2执行orElseGet处理后的值是"+result);
51    try {
52    result = optional1.orElseThrow (()-> new RuntimeException("值是空的"));
53    System.out.println("optional1执行orElseThrow处理后的值是"+result);
54    }catch (Exception e){
55        System.out.println("optional1的orElseThrow抛出异常:"+e.getMessage());
56    }
57    try {
58    result = optional2.orElseThrow (()-> new RuntimeException("值是空的"));
59    System.out.println("optional2执行orElseThrow处理后的值是"+result);
60    }catch (Exception e){
61        System.out.println("optional2的orElseThrow抛出异常:"+e.getMessage());
62

4）运行结果在这里插入图片描述

2.3.5 过滤方法 1）源码

1
2public Optional<T> filter(Predicate<? super T> predicate) {
3    Objects.requireNonNull(predicate);
4    if (!isPresent())
5        return this;
6    else
7        return predicate.test(value) ? this : empty();
8}

2）方法说明

filter(Predicate p): 如果optional不为空，则执行Predicate p，如果p的结果为true，则返回原本的optional，否则返回空的optional

3）测试代码

1
2public static void main(String[] args) {
3    Integer value1 = 5;
4    Integer value2 = 6;
5    Optional<Integer> optional1 = Optional.ofNullable(value1);
6    Optional<Integer> optional2 = Optional.of(value2);
7 
8 
9    Optional<Integer> result =optional1.filter(t->t > 5);
10    System.out.println("optional1的filter后的值:"+result);
11     result =optional2.filter(t->t > 5);
12    System.out.println("optional2的filter后的值:"+result);

4）运行结果在这里插入图片描述

2.3.6 映射方法 1）源码

1
2public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
3    Objects.requireNonNull(mapper);
4    if (!isPresent())
5        return empty();
6    else {
7        return Optional.ofNullable(mapper.apply(value));
8    }
9}
10public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
11    Objects.requireNonNull(mapper);
12    if (!isPresent())
13        return empty();
14    else {
15        return Objects.requireNonNull(mapper.apply(value));
16    }
17}
18

2）方法说明

map(Function mapper): 如果存在一个值，则对其应用提供的映射函数，如果结果非空，则返回描述结果的Optional。否则返回一个空的Optional。
flatMap(Function< T,Optional> mapper): 如果有值，则对其应用提供的可选映射函数，返回结果，否则返回空的可选函数。这个方法类似于map(Function)，但是提供的映射器的结果已经是一个可选的，如果调用，flatMap不会用额外的可选的包装它。
区别：map会自动将u放到optional中，而flatMap则需要手动给u创建一个optional

3）测试代码

1
2    public static void main(String[] args) {
3        User user1 = null;
4        User user2 = new User("user2名字",19);
5        Optional<User> optional1 = Optional.ofNullable(user1);
6        Optional<User> optional2 = Optional.of(user2);
7        System.out.println("=========map==========");
8        System.out.println("optional1的map前的值:"+optional1);
9        Optional<String> result =optional1.map(t->t.getName());
10        System.out.println("optional1的map后的值:"+result);
11 
12 
13        System.out.println("optional2的map前的值:"+optional2);
14        result =optional2.map(t->t.getName());
15        System.out.println("optional2的map后的值:"+result);
16 
17 
18        System.out.println("===========flatMap========");
19 
20 
21        System.out.println("optional1的flatMap前的值:"+optional1);
22        Optional<Integer> result2 =optional1.flatMap(t->Optional.ofNullable(t.getAge()));
23        System.out.println("optional1的flatMap后的值:"+result2);
24 
25 
26        System.out.println("optional2的flatMap前的值:"+optional2);
27        result2 =optional2.flatMap(t->Optional.ofNullable(t.getAge()));
28        System.out.println("optional2的flatMap后的值:"+result2);
29 
30    }
31public class User {
32    String name;
33    Integer age;
34    public User(String name,Integer age){
35        this.name = name;
36        this.age=age;
37    }
38 
39 
40    public String getName() {
41        return name;
42    }
43 
44 
45    public Integer getAge() {
46        return age;
47

4）运行结果在这里插入图片描述

3 应用实例

3.1 错误用法

由于Optional并没有实现Serializable接口,所以不能作为类的属性。
不要把Optional作为方法的参数。
把if(x!=null)直接换成Optional.ofNullable(x).isPresent(),这样有过度编码的嫌疑。
直接使用Optional.get()的返回值进行操作，String result =Optional.ofNullable(null).get().toString()；这样还是会抛出异常的。

3.2 建议用法

A类有属性B类，B类有属性C类,C类有name这个字段。使用Optional之前:

1
2if(atest!=null){
3    Btest btest =atest.getBtest();
4    if(btest!=null){
5      Ctest ctest = btest.getCtest();
6      if (ctest != null) {
7          name =ctest.getName();
8      }
9    }
10}

使用Optional之后:

1
2name = Optional.ofNullable(atest).map(t->t.getBtest()).map(t->t.getCtest()).map(t->t.getName()).orElse("默认值");

代码是不是看上去更整洁了呢？

4 总结

通过对Optional源码解析和用例测试代码的运行结果，可以看出使用Optional可以优化null值判断代码，让代码变得更加优雅和整洁。

作者：陈昌浩 Description

Optional源码解析与实践

1 导读

2 源码解析

2.1 Optional定义

2.2 Optional的属性

2.3 Optional的方法

3 应用实例

3.1 错误用法

3.2 建议用法

4 总结

评论区

相关推荐