【Java8】Java8实战之Optional

Java8实战之Optional

前言

在前面的几个小节中，我们已经学习了Lambda表达式、Stream以及默认方法，在体会到Java8所带来的极大的便利之后，这小节我们来学习Java8中一个新的功能–Optional。

Optional

Optional的出现是为了解决null的问题，在Java中，如果一个对象指针没有被初始化，默认就指向null，而这种情况是比较危险的，在使用的时候，如果忘记对变量进行非空检测，当变量为null的时候，一调用就会出现NullPointerException，这是比较令人头疼的问题，在Java8中，引入了Optional<T>来替代null，Optional<T>的原理其实也比较简单，通过将一个对象包装起来，然后对外提供相应的操作方法，并且在方法内实现了相应地检测操作，这样子就能够避免操作者不小心操作到null而触发空指针异常了

由于Optional使用起来比较简单，加上其代码也比较好理解，这里我们直接分析其源码，增长下见识

public final class Optional<T> {

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

    private final T value;

    private Optional() {
        this.value = null;
    }
}

可以看到，Optional<T>中仅有两个成员，一个是EMPTY,其值就是null，另一个就是要求调用者传入的了。

接下来我们来看下Optional是如何构造了，除了上面的默认的EMPTY外，还有下面几种构造方式

// 静态方法构造一个empty对象，其实就是null
public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}

// 私有构造函数，需要传入非null的值，对应前面的null值的私有构造函数
private Optional(T value) {
    this.value = Objects.requireNonNull(value);
}

// 将一个值包装成Optional对象
public static <T> Optional<T> of(T value) {
    return new Optional<>(value);
}

// 允许构造其值可能为null的Optional对象
public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

接下来再来看下一些其他的操作方法

// 获取Optional包装的值，如果值为null，则抛出异常
public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

// 检查对象是否为空
public boolean isPresent() {
    return value != null;
}

// 如果非null，则进行相应操作
public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
        consumer.accept(value);
}

// 如果为null，直接返回，否则，如果满足对应的条件，则返回该对象，否则返回empty对象
public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent())
        return this;
    else
        return predicate.test(value) ? this : empty();
}

// 如果非null，则进行对应的映射操作
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));
    }
}

// 同上，只是映射操作为flatmap而不是map
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));
    }
}

// 如果非null，则返回本身，否则返回传入的other对象
public T orElse(T other) {
    return value != null ? value : other;
}

// 同上，并且返回其值，而不是对象本身
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

// 如果是null，则抛出异常
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

// toString、hashCode、equals这几个方法就不分析了

从JDK的源码中我们可以看到，其实Optional<T>就是对对象的封装，并且提供一些附加的操作，这看上去好像没什么必要，其实这也是一种折中的方法，毕竟null已经用了好久，要保持向下的兼容，也只能这样了。

总结

本小节主要介绍了Optional<T>的背景以及用途，然后从源码的角度分析了Optional<T>，从源码中我们也可以看到原来Optional<T>的实现只是简单的对对象进行封装，并且在对外提供的方法中进行了一系列的校验。