Java进阶篇（2）—Optional类（预防空指针NPE）

JAVA && Spring && SpringBoot2.x — 学习目录

Optional是JDK8引入的新特性，旨在解决空指针异常问题（后文采用NPE代指）。您可以将其看做为一个容器，可以存放null值或非null的对象，Optional类目的是迫使用户注意可能存在的NPE问题。关于它是否可以取代null值，可以参考下Java进阶篇（3）—Optional（是否使用Optional来代替null）这篇文章。

Optional不推荐作为属性、方法参数、集合元素。因为完全可以使用null值来取代Optional，并且Optional效率更加低下。甚至Optional类不能进行序列化。它的使用场景便在于可以作为方法返回值。来使得用户注意存在的NPE问题。

Optional类更像一把双刃剑，它可以尽量避免NPE对程序产生的潜在威胁，而且链式操作，可以更加直观、优雅的对复杂对象进行处理。但是它并不能解决NPE问题，并且它作为一个引用，效率会更加的低下。我们在使用过程中，不能滥用Optional类。

1. Optional类如何构建

既然Optional为存放对象的容器，我们首先考虑的如何将对象存入到Optional容器中。

方法	作用
Optional.of(obj)	它要求传入的 obj 不能是 null 值的, 若是null则抛出NullPointerException 异常上了
Optional.empty()	创建一个空的Optional对象
Optional.ofNullable(obj)	智能的创建Optional实例，即传入null则构建Optional.empty()，非null则构建Optional.of(obj)

2. Option类如何使用

上面我们说到Optional并不能解决NPE问题，我们使用《1. Optional类如何构建》方法，将null值存入了Optional类，使用get()方法获取值时，会出现NoSuchElementException异常。实际上，他只是将NullPointerException异常进行了转化。在调用get()方法时，必须调用isPresent()方法，去判断对象是否存在。

2.1 Optional使用的错误案例

但是你以为这样就是正确使用Optional的姿势吗？
反例：若是我们以为这样可以解决NullPointException问题，那么可真是有点大材小用了。

    @Test
    public void test2() {
        User user = null;
        //构建Optional对象
        Optional optional = Optional.ofNullable(user);
        //判断Optional对象是否存在
        if (optional.isPresent()) {
            //业务操作
            System.out.println(optional.get());
        } else {
            //异常处理
            throw new RuntimeException("user不存在");
        }
    }

由上例我们可以看出：isPresent()方法实际上和obj!=null方法没有任何的区别，若是没有isPresent()方法而单独使用get()调用。也可能存在NoSuchElementException异常。

Optional类型不能作为字段或者方法参数，Optional是一个类库方法，可明确表示可能无值请求下的返回类型。Optional类型不可序列化。

使用Optional时，应该尽量不调用Optional.get()方法，Optional.isPresent()更应该被看做一个私有的方法（在Optional中其他方法借助该方法进行逻辑判断），不应该用其处理NullPointerException异常。

2.2 Optional正确的使用方式

在Optional中我们真正可以依赖的是除了isPresent()和get()方法的其他方法：我们可以通过下列的方法完成Optional链式操作。

在链式操作中，若出现NPE问题，或Filter返回false，那么便会执行我们的异常方案，即orElse()/ofNullable /orElseThrow方法，我们无需在为空指针异常而担忧。我们便可以对该对象进行任意的操作。

//流类型转化
public Optional map(Function mapper)
//if...else
public T orElse(T other)
public T orElseGet(Supplier other)
//若存在的处理逻辑
public void ifPresent(Consumer consumer)
//筛选
public Optional filter(Predicate predicate)
public Optional flatMap(Function> mapper)
//若元素为null，则抛出指定的异常
public  T orElseThrow(Supplier exceptionSupplier) throws X

1. orElse 存在即返回，无则返回默认值

return user.orElse(null);  //而不是 return user.isPresent() ? user.get() : null;
return user.orElse(UNKNOWN_USER);

2. orElseGet 存在即返回，无则由函数产生

    @Test
    public void test() {
        User user = new User().setUserName("ll");
        Optional optional = Optional.ofNullable(user);
        //相当于三目表达式：return user.isPresent() ? user: getUser("aa");
        User user1 = optional.orElseGet(() -> getUser("aa"));
        System.out.println(user);
    }
    private User getUser(String id) {
        return new User();
    }

3. orElseThrow 存在即返回，无则抛出异常

    @Test
    public void test5() {
        User user = null;
        Optional optional = Optional.ofNullable(user);
        User user1 = optional.orElseThrow(() -> new RuntimeException("user不能为null"));
    }

4. ifPresent 若对象不为null，则进行操作

    @Test
    public void test3() {
        User user = new User().setUserName("ll");
        Optional optional = Optional.ofNullable(user);
        optional.ifPresent(o -> {
            Integer id = o.getId();
        });
      //而不要下边那样。
      if (optional.isPresent()) {
          System.out.println(optional.get());
      }
    }

5. map 若对象存在，则进行转换

    @Test
    public void test4() {

        User user = null;
        Optional optional = Optional.ofNullable(user);
        //map返回类型依旧为Optional类型
        Optional integer = optional.map(u -> u.getId());
        //若使用orElse()，只要出现null值，那么便转换为1
        Integer integer1 = optional.map(u -> u.getId()).orElse(1);
        System.out.println(integer1);
    }

    //相当于下面的使用
    @Test
    public void test41() {
        User user = null;
        if (user != null && user.getId() != null) {
            System.out.println(user.getId());
        } else {
            System.out.println(1);
        }
    }

6. filter过滤条件，不符合条件，则返回null

    @Test
    public void test6() {
        User user = new User().setUserName("aa").setUserAge(20);

        Optional user1 = Optional.of(user);
        //中间操作，不符合条件则为null
        User user2 = user1.filter(u -> "ab".equals(u.getUserName())).orElseThrow(RuntimeException::new);
    }

2.3 实战

校验user.getAge()是否0

    /**
     * 校验user.getAge()是否0 u.getAge())
                .map(u -> (u > 0 && u <= 100))
                .orElse(false);

        System.out.println(flag);
    }

2.4 封装工具类

public class OptionalUtils {

    /**
     * 若是null，则传入默认值
     */
    public static  T nullToDefault(T value, T defaultValue) {
        return Optional.ofNullable(value).orElse(defaultValue);
    }

    /**
     * 校验参数的时候，首先得去判断是否为空，太麻烦了，故抽取出来。先判断若是参数为null，则直接返回false。
     * 否则的话，则去执行filter的过滤操作
     */
    public static  boolean checkNoNPE(T value, Function filter) {
        return Optional.ofNullable(value).map(filter).orElse(false);
    }

    /**
     * 校验参数是否在指定范围之内。
     */
    public static boolean between(Double target, double begin, double end) {
        return Optional.ofNullable(target)
                .map(t -> (t >= begin && t < end))
                .orElse(false);
    }

    /**
     * 三目表达式——supplier?a:b
     */
    public static  T conditionalAB(Supplier supplier, T a, T b) {
        return nullToDefault(supplier.get(), false) ? a : b;
    }

    /**
     * 取代三目表达式
     */
    public static  T conditionalAB(boolean result, T a, T b) {
        return result ? a : b;
    }

}

3. lamda与Optional搭配（Guava提供）

使用jdk的lamda表达式解析集合时，在最后时可以转化为Optional。

MoreCollectors的API使用：

    com.google.guava
    guava
    31.0.1-jre

    public static void main(String[] args) {
        //集合
        List users = new ArrayList<>();
        User u1 = new User();
        u1.setAge(110);
        User u2 = new User();
        u2.setAge(10);

        users.add(u1);
        users.add(u2);

        //必须有limit(1)，将元素设置为Optional。在使用之前的方法
        Optional collect = users.stream().limit(1).collect(MoreCollectors.toOptional());
        System.out.println(collect.orElse(null));
    }

find的相关API：

    public static void main(String[] args) {
        List users = new ArrayList<>();
        User u1 = new User();
        u1.setAge(110);
        User u2 = new User();
        u2.setAge(10);
        users.add(u1);
        users.add(u2);
        /**
         * findAny返回值
         */
        Optional s = users.stream().findAny().map(User::getGj);
        /**
         * findFirst返回值
         */
        Optional s1 = users.stream().findFirst().map(User::getGj);
    }

参考

使用 Java 8 Optional 的正确姿势