Java8新特性Optional详解

Java8新特性Optional

概述

由于NullPointException这个错误是我们常间的错误，为了减少这样的错误，很多是否要对对象进行判断操作，Optional类就从此出现，为了减少NullPointException，优化我们的代码判断空指针的繁锁，且提供了一些方便的对象操作方法。

Optional是一个容器对象，内部存储需要操作的对象。存储存在的对象使用Optional.of();方法，如果该方法参数为空会抛出异常，避免这个问题就可以使用Optional.ofNullable();方法能够传入null值。

当我们存入对象到Optional时，可以使用Optional.isPresent()判断是否存在对象且对象不为null。为true就能够使用Optional.get();获取对象。

使用与案例

1. Optional提供的创建方法如下：

   • Optional.of(obj)：传入非空的Object对象。如果对象为 null，将会抛出NullPointerException。
   • Optional.ofNullable(obj)：如果对象为 null，将会创建不包含值的 EMPTY的 Optional对象实例（new Optional<>()）。
   • Optional.empty() ：创建一个空的Optional对象，等同于 Optional.ofNullable(null)。

2. 获取：

   • get()：获取optional实例中的对象，当optional 容器为空时报错

3. 判断：

   • isPresent()：判断optional是否为空，如果空则返回false，否则返回true

     List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6);
     Optional<List<Integer>> integers1 = Optional.of(integers);
     if (integers1.isPresent()) {
         List<Integer> integers3 = integers1.get();
         System.out.println(integers3);
     }
     // [1, 2, 3, 4, 5, 6]
     

   • ifPresent(Consumer c)：如果optional不为空，则将optional中的对象传给Comsumer函数

     ifPresent()方法使用会比isPresent()方便

     List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6);
     Optional<List<Integer>> integersOpt = Optional.of(integers);
     integersOpt.ifPresent(System.out::println);
     // [1, 2, 3, 4, 5, 6]
     

   • orElse(T other)：如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个默认值

     List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6);
     Optional<List<Integer>> integersOpt = Optional.of(integers);
     // 不为空
     System.out.println(integersOpt.orElse(integers));
     
     // 为空
     System.out.println(Optional.ofNullable(null).orElse("222"));
     // [1, 2, 3, 4, 5, 6]
     // 222
     

   • orElseGet(Supplier<T> other)：如果optional不为空，则返回optional中的对象；如果为null，则使用Supplier函数生成默认值other

     // 不为空时就是获取封装的对象，所以主要表现为空时的情况
     // 为空就返回一个集合
     Object o = Optional.ofNullable(null).orElseGet(ArrayList::new);
     System.out.println(o);
     // []
     

   • orElseThrow(Supplier<X> exception)：如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常

     // 不为空时就是获取封装的对象，所以主要表现为空时的情况
     Object o = Optional.ofNullable(null).orElseThrow(() -> new RuntimeException());
     // java.lang.RuntimeException
     

4. 过滤：

   • filter(Predicate<T> p)：如果optional不为空，则执行断言函数p，如果断言函数p的结果为true，则返回原本的optional。否则返回空的optional 。

     List<Integer> integers = Arrays.asList(1, null, 3, 4, 5, 6);
     Optional<List<Integer>> integersOpt = Optional.of(integers);
     // 过滤数组索引1的值不等于null，由于现在是null，所以返回是空的Optional
     // 空的Optional调用ifPresent方法没有输出
     integersOpt.filter(integers1 -> integers1.get(1) != null)
             .ifPresent(integers1 -> System.out.println(integers1));
     

5. 映射：

   • map(Function<T, U> mapper)：如果optional不为空，则将optional中的对象映射成另外一个对象 ，并将另外一个对象存放到一个新的optional容器中。

     List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6);
     Optional<List<Integer>> integersOpt = Optional.of(integers);
     Optional<Integer> integer = integersOpt.map(integers1 -> integers1.get(1));
     System.out.println(integer.get());
     // 2
     

   • flatMap(Function< T,Optional<U>> mapper)：跟上面一样，在optional不为空的情况下，通过操作将对象映射成另外一个optional。

     List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6);
     Optional<List<Integer>> integersOpt = Optional.of(integers);
     Optional<Integer> integer = integersOpt.flatMap(integers1 -> {
         Integer integer1 = integers1.get(1);
         Integer integer2 = integers.get(2);
         // 添加，作为一个Optional返回
         return Optional.ofNullable(integer1 + integer2);
     });
     System.out.println(integer.get());
     // 5
     

总结

Optional能够很好的去处理我们平时出现的NullPointException，优化我们对象的判空代码，提供一些更方便的代码去避免出现NullPointException处理数据。

参考文档

https://juejin.cn/post/6962325858145009672

https://blog.csdn.net/y_k_y/category_8596455.html

https://www.baeldung.com/java-optional