使用Optional：解决NPE问题的更优雅的写法

最新推荐文章于 2023-05-18 18:21:06 发布

再写三行

最新推荐文章于 2023-05-18 18:21:06 发布

阅读量187

点赞数

分类专栏： java学习文章标签： java

本文链接：https://blog.csdn.net/baidu_33403616/article/details/121142497

版权

java学习专栏收录该内容

25 篇文章 0 订阅

订阅专栏

本文深入讲解了Java 8中引入的Optional模式，旨在减少空指针异常的风险，并提高代码的可读性和简洁性。通过对比传统if语句的检查方式与Optional的链式调用，展示了如何使用Optional来优雅地处理可能为null的对象引用。

摘要由CSDN通过智能技术生成

1.使用背景

避免产生很多的循坏if调用，使得代码更清晰易懂。

反列：

    if (query!= null) {
         Result result = query.getResult();
        if (result != null) {
           User user = result.getUser();
            if (user != null) {
                 return user.getName();
             }
         }
    }
   
    throw new testException("throw error exception");

正列

 return Optinal.ofNullable(query)
                    .map(c->c.getResult())
                    .map(r->r.getUser())
                    .map(u->u.getName())
                    .orElseThrow(()->new testException("throw error exception"))

2.Api使用

* Optional.of 传入的值存在，返回包含该值的Optional对象，否则就抛出NullPointerException异常
* Optional.ofNullable 传入的值存在，返回包含该值的Optional对象，否则返回一个空的Optional对象
* Optional.isPresent 如果值存在就返回true  否则返回false
* Optional.ifPresent 如果值存在就对该值执行传入的方法，否则就什么也不做
* Optional.orElse 如果值存在就将其值返回，否则返回传入的默认值
* Optional.map 如果值存在，就对该值执行提供的mapping函数调用，将mapping函数返回值用Optional封装并返回

public class OptionalTest {
    public static  void main(String []args){
        // Optional.of 用法 不是null
        Optional<String>optional = Optional.of("1");
        System.out.println(optional.isPresent());//true
        System.out.println(optional.get());//1
       // Optional.of 用法 是null
       Optional<String>optional1 = Optional.of(null);// 报空指针异常


        // Optional.of Nullable 用法 不是null
        Optional<String>optional2 = Optional.ofNullable("1");
        System.out.println(optional2.isPresent());//true
        System.out.println(optional2.get());//1
        //Optional.of Nullable 用法 是null
        Optional<String>optional3 = Optional.ofNullable(null);
        System.out.println(optional3.isPresent());//false
        System.out.println(optional3.get());//报 java.util.NoSuchElementException: No value present 异常


       //Optional.ifPresent 用法 不是null
        Optional<String>optional4 = Optional.ofNullable("1");
        optional4.ifPresent(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });//1

        //Optional.ifPresent 用法 是null
        Optional<String>optional5 = Optional.ofNullable(null);
        optional5.ifPresent(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });//没有输出

        // Optional.orElse 用法  不是null
        Optional<String>optional6 = Optional.ofNullable("1");
        System.out.println(optional6.orElse("2"));//1

        // Optional.orElse 用法  是null
        Optional<String>optional7 = Optional.ofNullable(null);
        System.out.println(optional7.orElse("2"));//2

        // Optional.map用法  不是null
        Optional<String>optional8 = Optional.ofNullable("1");
        Optional<String>newOptional8 =optional8.map((a)->a+"value");
        System.out.println(newOptional8.get());//1value

        //Optional.map用法  是null
        Optional<String>optional9 = Optional.ofNullable(null);
        Optional<String>newOptional9 =optional9.map((a)->a+"value");
        System.out.println(newOptional9.get());//java.util.NoSuchElementException: No value present


        //demo
        Integer test =1;
        if(test!=null){
            System.out.println(test);
        }
        //错误改写
        Optional<Integer>test1 = Optional.ofNullable(1);
        if(test1.isPresent()){
            System.out.println(test1.get());
        }
        //正确改写
        Optional.ofNullable(1).ifPresent(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });

    }
}