• 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.  */
    4. private static final Optional<?> EMPTY = new Optional<>();
    5.  
    6.  
    7. /**
    8.  * If non-null, the value; if null, indicates no value is present
    9.  */
    10. private 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.  */
    7. private 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. */
    18. private Optional(T value) {
    19.     this.value = Objects.requireNonNull(value);
    20. }

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

    2.3.2 创建方法

    1）源码

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

    2）方法说明

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

    3）测试代码

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

    4）运行结果

    2.3.3 值获取方法

    1）源码

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

    2）方法说明

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

    3）测试代码

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

    4）运行结果

    2.3.4 判断方法

    1）源码

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

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

    4）运行结果

    2.3.5 过滤方法

    1）源码

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

    2）方法说明

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

    3）测试代码

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

    4）运行结果

    2.3.6 映射方法

    1）源码

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

    2）方法说明

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

    3）测试代码

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

    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. if(atest!=null){
    2.     Btest btest =atest.getBtest();
    3.     if(btest!=null){
    4.       Ctest ctest = btest.getCtest();
    5.       if (ctest != null) {
    6.           name =ctest.getName();
    7.       }
    8.     }
    9. }

    使用Optional之后:

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

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

    4 总结

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

    作者：陈昌浩

  • 相关阅读:
    Seata概述
    关于js的类型转换（强制类型和隐式类型）
    【gcc】RtpTransportControllerSend学习笔记 3：gcc 算法
    算法竞赛进阶指南：奇怪的汉诺塔（Python）
    酷宇宙观点：万物金融化，定义下一个金融服务时代
    【LeetCode-简单题】367. 有效的完全平方数
    【软件安装】Centos系统中安装docker容器（华为云HECS云耀服务器）
    DockerCompose
    聚酰胺改性乳清白蛋白/肌白蛋白/豆清白蛋白/蓖麻蛋白/豌豆白蛋白1b ( PA1b)纳米粒
    设置session失效时间
  • 原文地址：https://blog.csdn.net/jdcdev_/article/details/127103892