Optional与空指针问题的“不解之缘”

2023-12-02 18:34:04

Optional与空指针问题的“不解之缘”

一、前言
二、Optional源码分析
三、Optional实例

一、前言

对于NPE(NullPointerException)空指针问题，相信你已经恨死它了，但是它依然存在。同时，对于它的校验也使得优雅的代码，变得混乱。于是，Java 8版本推出了Optional类来优雅的解决程序中出现的NPE问题。

“A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value.” --《Java™ Platform Standard Ed. 8》
从官方的说明文档中可以了解到，Optional类是一个可能包含也可能不包含非空值的容器对象。如果Optional存在值，则它的isPresent() 将返回 true ，并且可通过 get() 方法返回该值。可能你还是有些迷惑，别急，咱们看看Optional的源码就知道这句话的含义了。

二、Optional源码分析

2.1、Optional(T value)

Optional类的构造函数，个人觉得是理解整个Optional类的关键，其源码构造如下图：

	// Optional 构造函数
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
	
	// java.util.Objects.java
	// Objects.requireNonNull方法
    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

2.2、of(T value)

由于Optional类的构造函数为private权限，不能被外部类所调用。因此，Optional类为使用者提供了**of(T value)**方法，帮助使用者间接调用构造函数。

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

2.3、ofNullable(T value)

可能细心的读者已经发现了，of(T value)方法在调用构造函数时，如果value依然为null，还是会抛出NPE异常，如果使用者没有自定义全局统一异常处理的话，of(T value)方法并没有解决到NPE问题。因此，Optional类又为使用者提供了ofNullable(T value)方法，帮助使用者从根本上解决了NPE问题的触发，保证了调用该方法的返回值不会为Null。因此，在大多数情况下，我们都使用的是ofNullable(T value)方法。

	// new Optional<>()
    private static final Optional<?> EMPTY = new Optional<>();
    
    private Optional() {
        this.value = null;
    }
    
    // ofNullable(T value) 方法
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
	
	// 空对象（非Null)
	public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

2.4、orElse和orElseGet的区别

orElse方法：如果有值则返回该值，否则返回传递给它的参数值
orElseGet方法：如果有值的则返回该值，如果没有值，它会执行作为参数传入的 Supplier(供应者) 函数式接口，并将返回其执行结果
因此，这两个方法一个是传值，一个是传函数。同时对于方法中的value值，是已经在调用这两个方法的之前，就已经确定了，也就是Optional的value属性。而orElseGet方法也是Java 实现函数式编程的强劲一步，并且可以在范式中实现。

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

2.5、isPresent和ifPresent的区别

isPresent方法：判断value值是否为空
ifPresent方法：判断value值是否为空，在value值不为空时，接受一个Consumer(消费者) 参数，并执行传入的 Lambda 表达式。

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

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

三、Optional实例

    public static void main(String[] args) {
        Integer valueNull = null;
        Integer valueNotNull = 20;

        // Optional.ofNullable() 允许传递null参数
        Optional<Integer> a = Optional.ofNullable(valueNull);
        Optional<Integer> a1 = Optional.ofNullable(valueNotNull);
        System.out.println("ofNullable-> " + " valueNull: " + a + "   valueNotNull: " + a1);
        System.out.println("a 存在 ？ " + a.isPresent());
        System.out.println("a1 存在 ？ " + a1.isPresent());

        // Optional.of() -不允许传递null参数，否则会抛出NPE
        Optional<Integer> b = Optional.of(valueNotNull);
        //Optional<Integer> b1 = Optional.of(valueNull); 抛出异常，程序中断
        System.out.println("of-> " + " valueNull: " + b);
        System.out.println("b 存在 ？ " + b.isPresent());
        //System.out.println("b1 存在 ？ " + b1.isPresent());

        //Optional.orElse 如果值存在，则返回它，否则返回默认值
        Integer valueOrElseA = a.orElse(new Integer(21));
        System.out.println("valueOrElseA: " + valueOrElseA);
        Integer valueOrElseA1 = a1.orElse(new Integer(21));
        System.out.println("valueOrElseA1: " + valueOrElseA1);

        //Optional.orElseGet 如果值存在，则返回它，否则执行传入方法，并返回执行结果
        Integer valueOrElseGetA = a.orElseGet(() -> {
            int t1 = 20;
            int t2 = 20;
            return t1 + t2;
        });
        System.out.println("valueOrElseGetA: " + valueOrElseGetA);
        Integer valueOrElseGetA1 = a1.orElseGet(() -> (1 + 2));
        System.out.println("valueOrElseGetA1: " + valueOrElseGetA1);
    }

输入结果：

ofNullable->  valueNull: Optional.empty   valueNotNull: Optional[20]
a 存在 ？ false
a1 存在 ？ true
of->  valueNull: Optional[20]
b 存在 ？ true
valueOrElseA: 21
valueOrElseA1: 20
valueOrElseGetA: 40
valueOrElseGetA1: 20

至此，相信各位已经对Optional类的使用，已经有一个深入的理解了。因此，一般情况下，我们较为习惯的使用ofNullable() 来避免空指针问题，而 orElse()和orElseGet()的使用，根据传入的参数来判断。如果是传入的一个已知的值（变量）则可用orElse()，如果传入的是一个方法则使用orElseGet()。

码农公寓