Optional源码详解

package java.util;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * A container object which may or may not contain a non-null value.
 * If a value is present, {@code isPresent()} will return {@code true} and
 * {@code get()} will return the value.
 *
 * <p>Additional methods that depend on the presence or absence of a contained
 * value are provided, such as {@link #orElse(java.lang.Object) orElse()}
 * (return a default value if value not present) and
 * {@link #ifPresent(java.util.function.Consumer) ifPresent()} (execute a block
 * of code if the value is present).
 *
 * <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
 * class; use of identity-sensitive operations (including reference equality
 * ({@code ==}), identity hash code, or synchronization) on instances of
 * {@code Optional} may have unpredictable results and should be avoided.
 *
 * @since 1.8
 */
public final class Optional<T> {
    /**
     * Common 实例
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * 如果非空则有值，如果是null则无值
     */
    private final T value;

    /**
     * 创建一个空实例
     */
    private Optional() {
        this.value = null;
    }

    /**
     * 返回一个容器里面为空的Optional对象，也就是说这个容器对象里面的那个值value肯定是为空的null；
     */
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    /**
     * 私有的构造方法，传入值不能为空不然抛出NullPointerException 异常
     */
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    /**
     * 创建一个有值的Optional对象，传入值必须有值，不然就会抛出NullPointerException异常
     */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    /**
     * 构造一个可能为空也可能不为空的容器，传入值不确定是否为空
     */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    /**
     * 传出value，如果value为则抛出NoSuchElementException("No value present")异常
     */
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    /**
     * 判断容器值是不是空
     */
    public boolean isPresent() {
        return value != null;
    }

    /**
     * 如果容器中的值不为空执行Consumer（消费者）函数
     */
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

    /**
     * 如果存在一个值与Predicate函数的操作匹配则返回值，如果不匹配返回一个空的容器
     */
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

    /**
     * 如果存在值，则将提供的映射函数应用于该值，如果结果为非null，则返回描述结果的Optional。否则返回空Optional
     */
    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));
        }
    }

    /**
	* 如果存在值，则将提供的Optional-bearing映射函数应用于该值，返回该结果，否则返回空Optional。这个方法类似于
	* map(Function)，但提供的映射器是一个结果已经是Optional的映射器，如果被调用，flatMap不会附加一个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;
    }

    /**
     * 如果容器中有值则返回容器值，容器没有值返回Supplier函数执行结果
     */
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

    /**
     * 如果容器有值则返回容器值，没有值则抛出 Supplier 定义的异常
     */
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

    /**
     * 复写方法
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof Optional)) {
            return false;
        }

        Optional<?> other = (Optional<?>) obj;
        return Objects.equals(value, other.value);
    }

    /**
     * 复写方法
     */
    @Override
    public int hashCode() {
        return Objects.hashCode(value);
    }

    /**
     * 复写方法
     */
    @Override
    public String toString() {
        return value != null
            ? String.format("Optional[%s]", value)
            : "Optional.empty";
    }
}

推荐--https://solang.blog.csdn.net/article/details/99897684?utm_medium=distribute.pc_relevant_t0.none-task-blog-2~default~CTRLIST~default-1.no_search_link&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2~default~CTRLIST~default-1.no_search_link