Optional源码分析（涉及Objects源码和Stream源码）

研究Optional源码之前先谈一谈Objects源码。

主要代码：

  @ForceInline
    public static <T> T requireNonNull(T obj) {
        if (obj == null) {
            throw new NullPointerException();
        } else {
            return obj;
        }
    }

    @ForceInline
    public static <T> T requireNonNull(T obj, String message) {
        if (obj == null) {
            throw new NullPointerException(message);
        } else {
            return obj;
        }
    }

这个代码很简单等于null就抛异常，不等于null就返回原先的对象，在Optional的引用为：

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

       public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        return this.isEmpty() ? empty() : ofNullable(mapper.apply(this.value));
    }

    public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        Objects.requireNonNull(mapper);
        if (this.isEmpty()) {
            return empty();
        } else {
            Optional<U> r = (Optional)mapper.apply(this.value);
            return (Optional)Objects.requireNonNull(r);
        }
    }

    public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
        Objects.requireNonNull(supplier);
        if (this.isPresent()) {
            return this;
        } else {
            Optional<T> r = (Optional)supplier.get();
            return (Optional)Objects.requireNonNull(r);
        }
    }

可以看到在每一个操作前面都进行了Objects.requireNonNull(对象);的这个判断

@ValueBased
public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional((Object)null);
    private final T value;

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

Optional类有一个变量为T value对象，这个对象则是用于存传进的参数对象的。

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

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

这个代码就很有意思。value要是等于null的话，就让它转化为Optional对象，从而避免空指针异常。

    public boolean isEmpty() {
        return this.value == null;
    }

 public Stream<T> stream() {
        return this.isEmpty() ? Stream.empty() : Stream.of(this.value);
    }

this.isEmpty()为true返回Stream.empty(),否则就返回Stream.of(this.value)，转化为Stream类型。

以下是steam的empty源码。

  static <T> Stream<T> empty() {
        return StreamSupport.stream(Spliterators.emptySpliterator(), false);
    }

该方法就是返回一个空的Stream

而Stream.of(this.value)就是单纯的把value对象放进stream流里面。

代码演示：

可知不会出现空指针异常。