Java 8 中使用 Optional 处理 null 对象

2020-07-21 00:15:00 java optional

文章目录

系统环境：

Java JDK 版本：1.8

参考地址：

一、Optional 简介

Optional 是一个容器对象，可以存储对象、字符串等值，当然也可以存储 null 值。Optional 提供很多有用的方法，能帮助我们将 Java 中的对象等一些值存入其中，这样我们就不用显式进行空值检测，使我们能够用少量的代码完成复杂的流程。

比如它提供了：

of() 方法，可以将值存入 Optional 容器中，如果存入的值是 null 则抛异常。
ofNullable() 方法，可以将值存入 Optional 容器中，即使值是 null 也不会抛异常。
get() 方法，可以获取容器中的值，如果值为 null 则抛出异常。
getElse() 方法，可以获取容器中的值，如果值为 null 则返回设置的默认值。
isPresent() 方法，该方法可以判断存入的值是否为空。
...等等一些其它常用方法，下面会进行介绍。

可以说，使用 Optional 可以帮助我们解决业务中，减少值动不动就抛出空指针异常问题，也减少 null 值的判断，提高代码可读性等，这里我们介绍下，如果使用这个 Optional 类。

二、Optional 类描述

Optional 类所在包： java.util.Optional
Optional 类声明： public final class Optional extends Object
Optional 类方法：

public Optional filter(Predicate<? super T> predicate)

方法名称	修饰符、返回类型	方法描述
empty()	static <T> Optional<T>	方法描述
equals(Object obj)	boolean	判断其他对象是否等于 Optional。
filter(Predicate<? super T> predicate)	Optional<T>	如果有值并且满足断言条件返回包含该值的 Optional，否则返回空 Optional。
get()	T	如果在这个 Optional 中包含这个值则返回值，否则抛出 NoSuchElementException 异常。
hashCode()	int	返回存在值的哈希码，如果值不存在则返回 0。
ifPresent(Consumer<? super T> consumer)	void	如果值存在则使用该值调用 consumer , 否则不做任何事情。
isPresent()	boolean	如果值存在则方法会返回 true，否则返回 false。
flatMap(Function<? super T,Optional<U>> mapper)	<U>Optional<U>	如果值存在，返回基于 Optional 包含的映射方法的值，否则返回一个空的 Optional。
map(Function<? super T,? extends U> mapper)	<U>Optional<U>	如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的 Optional 作为 map 方法返回值，否则返回空 Optional。
of(T value)	static <T> Optional<T>	返回一个指定非 null 值的 Optional。
ofNullable(T value)	static <T> Optional	果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。
orElse(T other)	T	如果该值存在就直接返回，否则返回指定的其它值。
orElseGet(Supplier<? extends T> other)	T	如果该值存在就返回值，否则触发 other，并返回 other 调用的结果。
orElseThrow(Supplier<? extends X> exceptionSupplier)	<X extends Throwable> T	如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常。
toString()	String	返回一个 Optional 的非空字符串，用来调试。

三、Optional 常用方法及使用示例

1、静态方法 Optional.of()

方法作用： 为指定的值创建一个指定非 null 值的 Optional。
方法描述： of 方法通过工厂方法创建 Optional 实例，需要注意的是传入的参数不能为 null，否则抛出 NullPointerException。
返回类型： Optional
示例代码：

调用两个 Optional.of() 方法，一个传入正常参数，另一个传入 null 参数：

1public static void main(String[] args) {
2    // 传入正常值，正常返回一个 Optional 对象
3    Optional<String> optional1 = Optional.of("mydlq");
4    
5    // 传入参数为 null，抛出 NullPointerException.
6    Optional optional2 = Optional.of(null);
7}

运行代码，可以观察到控制台输出内容如下：

1Exception in thread "main" java.lang.NullPointerException
2	at java.util.Objects.requireNonNull(Objects.java:203)
3	at java.util.Optional.<init>(Optional.java:96)
4	at java.util.Optional.of(Optional.java:108)
5	at club.mydlq.OptionalExample.main(OptionalExample.java:12)

可以看到传入正常参数正常返回 Optional 对象，传入 null 参数返回 NullPointerException 异常。

2、静态方法 Optional.ofNullable()

方法作用： 为指定的值创建一个 Optional 对象，如果指定的参数为 null，不抛出异常，直接则返回一个空的 Optional 对象。
方法描述： ofNullable 方法是和 of 方式一样，都是用于创建 Optional 对象，只是传入的参数 null 时，会返回一个空的 Optional 对象，而不会抛出 NullPointerException 异常。
返回类型： Optional
示例代码：

调用 Optional.ofNullable() 方法，传入 null 参数：

1public static void main(String[] args) {
2    // 传入正常值，正常返回一个 Optional 对象
3    Optional<String> optional1 = Optional.ofNullable("mydlq");
4    
5    // 传入 null 参数，正常返回 Optional 对象
6    Optional optional2 = Optional.ofNullable(null);
7}

运行代码，可以观察到正常传入值和传入 null 值时，都没有抛出异常。

3、对象方法 isPresent()

方法作用： 如果值存在则方法会返回 true，否则返回 false。
方法描述： 该方法其实就是用于判断创建 Optional 时传入参数的值是否为空，实现代码就简单一行，即 value != null 所以如果不为空则返回 true，否则返回 false。
返回类型： boolean
示例代码：

1public static void main(String[] args) {
2    // 传入正常值，正常返回一个 Optional 对象，并使用 isPresent 方法
3    Optional optional1 = Optional.ofNullable("mydlq");
4    System.out.println("传入正常值返回：" + optional1.isPresent());
5
6    // 传入参数为 null 生成一个 Optional 对象，并使用 isPresent 方法
7    Optional optional2 = Optional.ofNullable(null);
8    System.out.println("传入 null 值返回：" + optional2.isPresent());
9}

运行代码，可以观察到控制台输出内容如下：

1传入正常值返回：true
2传入 null 值返回：false

可以看到传入正常参数时调用 Optional 对象的 isPresent 方法时返回 true，传入 null 参数返回 false。

4、对象方法 get()

方法作用： 如果 Optional 有值则将其返回，否则抛出 NoSuchElementException 异常。
方法描述： get 方法内部实现其实就是判断 Otpional 对象中的 value 属性是否为 null，如果是就抛出 NoSuchElementException 异常，否则返回这个 value 值。
返回类型： T
示例代码：

1public static void main(String[] args) {
2    // 传入正常值，正常返回一个 Optional 对象，并使用 get 方法获取值
3    Optional optional1 = Optional.ofNullable("mydlq");
4    System.out.println(optional1.get());
5
6    // 传入参数为 null 生成一个 Optional 对象，并使用 get 方法获取值
7    Optional optional2 = Optional.ofNullable(null);
8    System.out.println(optional2.get());
9}

运行代码，可以观察到控制台输出内容如下：

1传入正常参数：mydlq
2Exception in thread "main" java.util.NoSuchElementException: No value present
3	at java.util.Optional.get(Optional.java:135)
4	at club.mydlq.OptionalExample.main(OptionalExample.java:14)

可以观察到传入正常值的 Optional 调用 get 方法正常输出值，通过空的 optional 对象使用 get 方法获取值时，抛出 NoSuchElementException 异常：

5、对象方法 ifPresent()

方法作用： 如果值存在则使用该值调用 consumer , 否则不做任何事情。
方法描述： 该方法 ifPresent(Consumer<? super T> consumer) 中参数接收的是 Consumer 类，它包含一个接口方法 accept()，该方法能够对传入的值进行处理，但不会返回结果。这里传入参数可以传入 Lamdda 表达式或 Consumer 对象及实现 Consumer 接口的类的对象。
返回类型： void
示例代码：

 1public static void main(String[] args) {
 2    // 创建 Optional 对象，然后调用 Optional 对象的 ifPresent 方法，传入 Lambda 表达式
 3    Optional optional1 = Optional.ofNullable("mydlq1");
 4    optional1.ifPresent((value) -> System.out.println("Optional 的值为：" + value));
 5
 6    // 创建 Optional 对象，调用 Optional 对象的 ifPresent 方法，传入实现 Consumer 匿名内部类
 7    Optional optional2 = Optional.ofNullable("mydlq2");
 8    Consumer<String> consumer = new Consumer() {
 9        @Override
10        public void accept(Object value) {
11            System.out.println("Optional 的值为：" + value);
12        }
13    };
14    optional2.ifPresent(consumer);
15}

运行代码，可以观察到控制台输出内容如下：

1Optional 的值为：mydlq1
2Optional 的值为：mydlq2

可以观察到，调用 ifPresent 使用 lambda 或者内部匿名类方法，都是为了再执行 Optional 对象的 ifPresent 方法时，执行一段代码逻辑。

6、对象方法 orElse()

方法作用： 如果该值存在就直接返回，否则返回指定的其它值。
方法描述： orElse 方法实现很简单，就是使用三目表达式对传入的参数值进行 null 验证，即 value != null ? value : other; 如果为 null 则返回 true，否则返回 false。
返回类型： T
示例代码：

 1public static void main(String[] args) {
 2    // 传入正常参数，获取一个 Optional 对象，并使用 orElse 方法设置默认值
 3    Optional optional1 = Optional.ofNullable("mydlq");
 4    Object object1 = optional1.orElse("默认值");
 5    System.out.println("如果值不为空："+object1);
 6
 7    // 传入 null 参数，获取一个 Optional 对象，并使用 orElse 方法设置默认值
 8    Optional optional2 = Optional.ofNullable(null);
 9    Object object2 = optional2.orElse("默认值");
10    System.out.println("如果值为空："+object2);
11}

运行代码，可以观察到控制台输出内容如下：

1如果值不为空：mydlq
2如果值为空：默认值

可以观察到，如果 Optional 的值为空，则返回 orElse() 方法设置的默认值，否则返回 Optional 中的值。

7、对象方法 orElseGet()

方法作用： 如果该值存在就返回值，否则触发 other，并返回 other 调用的结果。
方法描述： orElseGet 方法和 orElse 方法类似，都是在 Optional 值为空时，返回一个默认操作，只不过 orElse 返回的是默认值，而 orElseGet 是执行 lambda 表达式，然后返回 lambda 表达式执行后的结果。
返回类型： T
示例代码：

 1public static void main(String[] args) {
 2    // 传入正常参数，获取一个 Optional 对象，并使用 orElse 方法设置默认值
 3    Optional optional1 = Optional.ofNullable("mydlq");
 4    Object object1 = optional1.orElseGet(() -> {
 5        String defaultVal = "执行逻辑和生成的默认值";
 6        return defaultVal;
 7    });
 8    System.out.println("输出的值为："+object1);
 9
10    // 传入 null 参数，获取一个 Optional 对象，并使用 orElse 方法设置默认值
11    Optional optional2 = Optional.ofNullable(null);
12    Object object2 = optional2.orElseGet(() -> {
13        String defaultVal = "执行逻辑和生成的默认值";
14        return defaultVal;
15    });
16    System.out.println("输出的值为："+object2);
17}

运行代码，可以观察到控制台输出内容如下：

1输出的值为：mydlq
2输出的值为：执行逻辑和生成的默认值

可也观察到，当 Optional 值为不为空时正常返回带值的 Optional，如果 Optional 为空则返回 orElseGet 方法中 lambda 表达式执行后生成的值。

8、对象方法 orElseThrow()

方法作用： 如果 Optional 存在该值，返回包含的值，否则抛出由 Supplier 继承的异常。
方法描述： orElseThrow 方法其实就是判断创建 Optional 时传入的参数是否为 null，如果是非 null 则返回传入的值，否则抛出异常。
返回类型： T
示例代码：

 1public static void main(String[] args) {
 2    // 传入正常参数，获取一个 Optional 对象，并使用 orElseThrow 方法
 3    try {
 4        Optional optional1 = Optional.ofNullable("mydlq");
 5        Object object1 = optional1.orElseThrow(() -> {
 6                    System.out.println("执行逻辑，然后抛出异常");
 7                    return new RuntimeException("抛出异常");
 8                }
 9        );
10        System.out.println("输出的值为：" + object1);
11    } catch (Throwable throwable) {
12        throwable.printStackTrace();
13    }
14    
15    // 传入 null 参数，获取一个 Optional 对象，并使用 orElseThrow 方法
16    try {
17        Optional optional2 = Optional.ofNullable(null);
18        Object object2 = optional2.orElseThrow(() -> {
19                    System.out.println("执行逻辑，然后抛出异常");
20                    return new RuntimeException("抛出异常");
21                }
22        );
23        System.out.println("输出的值为：" + object2);
24    } catch (Throwable throwable) {
25        throwable.printStackTrace();
26    }
27}

运行代码，可以观察到控制台输出内容如下：

1值为不为空输出的值：mydlq
2执行逻辑，然后抛出异常
3java.lang.RuntimeException: 抛出异常
4	at club.mydlq.OptionalExample.lambda$main$1(OptionalExample.java:25)
5	at java.util.Optional.orElseThrow(Optional.java:290)
6	at club.mydlq.OptionalExample.main(OptionalExample.java:23)

可以观察到，当创建 Optional 时如果传入的参数为空则执行 Lambda 表达式代码逻辑后抛出异常信息，否则返回传入的参数值。

9、对象方法 map()

方法作用： 如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的 Optional 作为 map 方法返回值，否则返回空 Optional。
方法描述： map 方法主要用于获取某个对象中的某个属性值的 Optional 对象时使用。map 方法调用时，首先验证传入的映射函数是否为空，如果为空则抛出异常。然后，再检测 Optional 的 value 是否为空，如果是，则返回一个空 value 的 Optional 对象。如果传入的映射函数和 Optinal 的 value 都不为空，则返回一个带 value 对象属性的 Optional 对象。
返回类型： Optional<U>
示例代码：

示例1： 创建 Map 集合，存储一些键值对信息，通过 Optional 操作 Map 获取值，然后观察：

 1public static void main(String[] args) {
 2    // 创建 map 对象
 3    Map<String, String> userMap = new HashMap<>();
 4    userMap.put("name1", "mydlq");
 5    userMap.put("name2", null);
 6
 7    // 传入 Map 对象参数，获取一个 Optional 对象，获取 name1 属性
 8    Optional<String> optional1 = Optional.of(userMap).map(value -> value.get("name1"));
 9
10    // 传入 Map 对象参数，获取一个 Optional 对象，获取 name2 属性
11    Optional<String> optional2 = Optional.of(userMap).map(value -> value.get("name2"));
12
13    // 获取 Optional 的值
14    System.out.println("获取的 name1 的值：" + optional1.orElse("默认值"));
15    System.out.println("获取的 name2 的值：" + optional2.orElse("默认值"));
16}

运行代码，可以观察到控制台输出内容如下：

1获取的 Optional 的值：mydlq
2获取的 Optional 的值：默认值

示例2： 创建一个用户类，使用 Optional 操作用户对象，获取其 name 参数，结合 Optional 的 map 方法获取值，进行观察：

 1public class User {
 2
 3    private String name;
 4    
 5    public User(String name) {
 6        this.name = name;
 7    }
 8
 9    public String getName() {
10        return name;
11    }
12    public void setName(String name) {
13        this.name = name;
14    }
15}

使用 Optional 的 map 方法对值处理：

 1public static void main(String[] args) {
 2    // 创建一个对象，设置姓名属性而不设置性别，这时候性别为 null
 3    User user1 = new User("测试名称");
 4    User user2 = new User();
 5
 6    // 使用 Optional 存储 User 对象
 7    Optional<User> optional1 = Optional.ofNullable(user1);
 8    Optional<User> optional2 = Optional.ofNullable(user2);
 9
10    // 获取对象的 name 属性值
11    String name1 = optional1.map(User::getName).orElse("未填写");
12    String name2 = optional2.map(User::getName).orElse("未填写");
13
14    // 输出结果
15    System.out.println("获取的名称：" + name1);
16    System.out.println("获取的名称：" + name2);
17}

运行代码，可以观察到控制台输出内容如下：

1获取的名称：测试名称
2获取的名称：未填写

总结：

通过上面两个示例观察到，通过 Optional 对象的 map 方法能够获取映射对象中的属，创建 Optional 对象，并以此属性充当 Optional 的值，结合 orElse 方法，如果获取的属性的值为空，则设置个默认值。

10、对象方法 flatMap()

方法作用： 如果值存在，返回基于 Optional 包含的映射方法的值，否则返回一个空的 Optional。
方法描述： flatMap 方法和 map 方法类似，唯一的不同点就是 map 方法会对返回的值进行 Optional 封装，而 flatMap 不会，它需要手动执行 Optional.of 或 Optional.ofNullable 方法对 Optional 值进行封装。
返回类型： Optional<U>
示例代码：

 1public static void main(String[] args) {
 2    // 创建 map 对象
 3    Map<String, String> userMap = new HashMap<>();
 4    userMap.put("name", "mydlq");
 5    userMap.put("sex", "男");
 6
 7    // 传入 Map 对象参数，获取一个 Optional 对象
 8    Optional<Map<String, String>> optional1 = Optional.of(userMap);
 9
10    // 使用 Optional 的 flatMap 方法，获取 Map 中的 name 属性
11    // 然后通过获取的值手动创建一个新的 Optional 对象
12    Optional optional2 = optional1.flatMap(value -> Optional.ofNullable(value.get("name")));
13
14    // 获取 Optional 的 value
15    System.out.println("获取的 Optional 的值：" + optional2.get());
16}

运行代码，可以观察到控制台输出内容如下：

1获取的 Optional 的值：mydlq

根据结果观察，可以看到 flatMap 和 map 方法没有什么区别，但是仔细看，代码中调用 flatMap 后，需要手动执行 of 或 ofNullable 方法创建了 Optional 对象。

11、对象方法 filter()

方法作用： 如果有值并且满足断言条件返回包含该值的 Optional，否则返回空 Optional。
方法描述： filter 方法通过传入的限定条件对 Optional 实例的值进行过滤，如果 Optional 值不为空且满足限定条件就返回包含值的 Optional，否则返回空的 Optional。这里设置的限定条件需要使用实现了 Predicate 接口的 lambda 表达式来进行配置。
返回类型： Optional<T>
示例代码：

 1public static void main(String[] args) {
 2    // 创建一个测试的 Optional 对象
 3    Optional<String> optional = Optional.ofNullable("mydlq");
 4    // 调用 Optional 的 filter 方法，设置一个满足的条件，然后观察获取的 Optional 对象值是否为空
 5    Optional optional1 =optional.filter((value) -> value.length() > 2);
 6    System.out.println("Optional 的值不为空：：" + optional.isPresent());
 7
 8    // 调用 Optional 的 filter 方法，设置一个不满足的条件，然后观察获取的 Optional 对象值是否为空
 9    Optional optional2 =optional.filter((value) -> value.length() <2);
10    System.out.println("Optional 的值不为空：：" + optional2.isPresent());
11}

运行代码，可以观察到控制台输出内容如下：

1Optional 的值不为空：true
2Optional 的值不为空：false

根据结果可以观察到，可以通过 filter 设置一个条件来判断 Optional 的值，如果满足条件就返回带值的 Optional，否则返回空的 Optional。

四、Optional 常用示例组合

在介绍一栏中已经说过 Optional 是个容器，它可用保存类型的 T 的值，即使 T 为 null 也可以使用 Optional 存储，这样我就不用显示进行空值检测，防止空指针异常。

上面也介绍了 Optional 的各种方法，在实际使用中这些方法常常组合使用。且很多方法也常与 Lambda 表达式结合，获取我们想要的结果的值。

下面是常用的示例，可以作为参考：

对集合中的对象属性进行过滤

创建一个 User 对象实体类，里面包含 name 属性：

 1public class User {
 2    private String name;
 3
 4    public User(String name) {
 5        this.name = name;
 6    }
 7
 8    public String getName() {
 9        return name;
10    }
11    public void setName(String name) {
12        this.name = name;
13    }
14}

创建一个使用 main 方法的类，创建几个 User 对象且设置不同的值，有的对象为 null 有的属性不设置，然后通过 Optional 获取 name 属性值加入集合，进行测试：

 1import java.util.ArrayList;
 2import java.util.List;
 3import java.util.Optional;
 4
 5public class OptionalExample {
 6
 7    /**
 8     * 测试的 main 方法
 9     */
10    public static void main(String[] args) {
11        // 创建一个测试的用户集合
12        List<User> userList = new ArrayList<>();
13
14        // 创建几个测试用户
15        User user1 = new User("abc");
16        User user2 = new User("efg");
17        User user3 = null;
18
19        // 将用户加入集合
20        userList.add(user1);
21        userList.add(user2);
22        userList.add(user3);
23
24        // 创建用于存储姓名的集合
25        List<String> nameList = new ArrayList();
26        // 循环用户列表获取用户信息，值获取不为空且用户以 a 开头的姓名，
27        // 如果不符合条件就设置默认值，最后将符合条件的用户姓名加入姓名集合
28        for (User user : userList) {
29            nameList.add(Optional.ofNullable(user).map(User::getName).filter(value -> value.startsWith("a")).orElse("未填写"));
30        }
31
32        // 输出名字集合中的值
33        System.out.println("通过 Optional 过滤的集合输出：");
34        nameList.stream().forEach(System.out::println);
35    }
36
37}

输出运行结果：

1通过 Optional 过滤的集合输出：
2abc
3未填写
4未填写

通过上面，可以观察到，使用 Optional 有时候可以很方便的过滤一些属性，而且它的方法可以通过链式调用，方法间相互组合使用，使我们用少量的代码就能完成复杂的逻辑。

---END---