读java Optional 源码

//该类是jdk1.8新增的类,主要是为了解决NPE问题。

//先看构造函数:

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

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

//可以看到构造函数都是私有的。所以可以推测创建该对象的方法应该是静态的。

//来看创建对象的方法:(都是静态方法)

   //结合上面的构造方法可以看到如果传入的value为null,会抛出NPE.
   public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
   //可以传入NULL
   public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

//再看其他方法:
   //返回空对象
   public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
  //获取对象。如果未null会抛NPE.
  public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
  //是否有value
  public boolean isPresent() {
        return value != null;
    }
  //如果有值,就消费该值
  public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }
  //符合当前断言则返回负责返回empty
  public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }
  //通过Function转换当前对象
  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的区别在于这里不会用optional封装,而是直接返回optional。
  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));
        }
    }

  public T orElse(T other) {
        return value != null ? value : other;
    }
  //如果是null,则从Supplier函数中get
  public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

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