Optional优雅处理空指针

咸鱼的想法

已于 2023-12-25 09:53:53 修改

阅读量230

点赞数

分类专栏： javaSE 文章标签： java 开发语言

于 2023-07-06 16:11:05 首次发布

本文链接：https://blog.csdn.net/qq_45738291/article/details/131579102

版权

javaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

背景：在业务中，我们常常需要去查询数据库或者调用某个方法时获取返回的对象，这种情况就是会存在返回对象为空的情况，因此我们需要作判断该对象是否为空，再进行后续获取属性或者方法调用等操作，否则就出现我们常见的NPE（NullPointerException）异常

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrderInfo(String Id);
if(Objects.nonNull(applyOrderInfo)){
    System.out.println(applyOrderInfo.getName());
}

获取订单名称的前提是查询的订单信息不能为空，这看似一步判断并没有什么影响，而且可读性也不错，为什么还要引入Optional优雅的解决空指针的问题呢？我们试着用Optional试试

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrderInfo(String Id);
Optional.ofNullable(applyOrderInfo).ifPresent(info->{
            System.out.println(applyOrderInfo.getName);
        });

确实看着高大上了一点，但是感觉怎么变复杂了呢？那我们再看看另一种情况，如果我们获取的对象中嵌套了对象，那我们就得嵌套几次就判断几次对象是否为空的操作，如下

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
if(Objects.nonNull(applyOrderInfo)){
    if(Objects.nonNull(applyOrderInfo.getCustInfo()))
        if(Objects.nonNull(applyOrderInfo.getCustInfo().getAddress())){
             System.out.println(applyOrderInfo.getCustInfo().getAdress().getCityAddress);
        }
   
}

如上，我们想获取订单信息中的顾客信息的所在地址的城市信息，发现需要判断三次是否为空，嵌套层级多了，代码就看着很难受，代码不够优雅，这就是所谓的钻石式代码，是不可取的。试着用一下Optional

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
String cityAddress = Optional.ofNullable(applyOrderInfo)
                .map(ApplyOrderInfo::getCustInfo)
                .map(CustInfo::getAddress)
                .map(Address::getCityAddress)
    		   .orElse("其他");

这看起来清爽多了！接下来详细介绍Optioanl

Optional

Optional在jdk1.8提出，属于jdk1.8新特性之一，目的在于优雅的解决业务中出现空指针异常，Optional相当于一个容器，将所需要的对象放入这个容器中，我们就可以根据这个容器有没有值做出相对应的一些操作，而不会因为这个对象为null报空指针异常。

这里大概将Optional中的方法分为三类：静态构造方法、Optional过程操作方法、Optional的终止操作方法。

静态构造方法

用于构造Optional这个容器

1、of()方法

public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

用来构造一个Optional对象，value入参值不可以为空，如果为空为报NullPointerException异常

显然，我们使用Optional本来就是要避免NullPointerException异常，所以构造Optional不会使用of方法

2、ofNullable()方法（重点）

用来构造一个Optional对象，value入参如果为null则返回一个不存在值的Optional空容器

public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

这个就是我们常用来构建Optional对象的方法，因为当入参对象value为null时，可以避免NullPointerException异常

3、empty()方法

private static final Optional<?> EMPTY = new Optional<>();

public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

构造一个空容器，为什么需要构造一个不存在值得Optional这个空容器呢？ofNullable方法的源码就知道了，这是用于当入参对象为空给出的一个兜底方法。

Optional的终止操作方法

Optional类中的方法返回参数的类型不同作为区分，如方法返回的结果不是是由Optional包装的对象，也就是说返回的不是容器，而是容器中的值，或者其他值。姑且称为Optional的终止操作方法

1、get()

public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

返回Option包装里面的对象，也就是容器中存放的值

例子

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
ApplyOrderInfo optionalApplyOrderInfo = Optional.ofNullable(applyOrderInfo)
                .get();

2、ifPresent(Consumer<? super T> consumer)

public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

入参是一个消费型函数式接口，用于消费Optional容器中的值，前提是容器中有值才会执行

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
Optional.ofNullable(applyOrderInfo)
                .ifPresent(info->{
                	info.setName("www");
                })

3、isPresent()

public boolean isPresent() {
    return value != null;
}

判断容器中是否存在值，存在返回true，反之false

例子

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
boolean flag =  Optional.ofNullable(applyOrderInfo)
                .isPresent();

4、orElse()

public T orElse(T other) {
        return value != null ? value : other;
    }

Optional中的兜底方法，当容器中存在值则返回值，如不存在则返回指定的值

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
String name =  Optional.ofNullable(applyOrderInfo)
                .map(ApplyOrderInfo::getName)
                .orElse("订单备用名称")

5、orElseGet(Supplier<? extends T> other)

public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

Optional中的兜底方法，当容器中存在值则返回值，如不存在则返回指定的回调方法

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
String name =  Optional.ofNullable(applyOrderInfo)
                .map(ApplyOrderInfo::getName)
                .orElseGet(()->{return "wwwp";});

小细节：orElse中也可以传入一个具有返回类型的回调函数，但是不建议使用，因为无论容器是否存在值，回调方法都是会执行的，只不过是当值存在返回的是值而不是回调方法的返回值，因此会带来性能上的消耗，有压栈过程，因此对于需要执行回调函数获取返回值的需要使用orElseGet()。

6、orElseThrow(Supplier<? extends X> exceptionSupplier)

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

Optional中的兜底方法，当容器中存在值则返回值，如果不存在则抛出指定的异常

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
String name =  Optional.ofNullable(applyOrderInfo)
                .map(ApplyOrderInfo::getName)
                .orElseThrow(()->new BizException("订单名称不能为空"));

Optional过程操作方法

Optional类中的方法返回参数的类型不同作为区分，如方法返回的结果仍是由Optional包装的对象，姑且称为Optional过程操作方法

1、filter()

public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

过滤指定条件的元素对象，入参是一个断言型函数式接口，返回过滤后的Optional对象

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
String name =  Optional.ofNullable(applyOrderInfo)
                .map(ApplyOrderInfo::getName)
                .filter(nameStr->!"".equals(nameStr))
                .orElseThrow(()->new BizException("订单名称不能为空"));

2、map(Function<? super T, ? extends U> mapper)

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

和流中的map类似，使用map可以将容器中的对象的某个属性映射出来，并再次进行Optional容器封装

例子

ApplyOrderInfo applyOrderInfo = applyOrderService.getApplyOrder(String Id);
String name =  Optional.ofNullable(applyOrderInfo)
                .map(ApplyOrderInfo::getName)
                .filter(nameStr->!"".equals(nameStr))
                .orElseThrow(()->new BizException("订单名称不能为空"));

map操作就是将订单信息中的name字段映射出来，拿到Optional< String > name值然后在进行后续Optional相关操作。

细节：那假设订单信息的name字段本来就是Optional< String > 修饰的属性呢？如果进行map操作那就会得到Optional< Optional< String >> ，被套了两层容器，那肯定我们是不想这样的，针对这种属性，我们提出了flatMap()方法。

3、flatMap(Function<? super T, Optional< U >> mapper)

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Objects.requireNonNull(mapper.apply(value));
        }
    }