（三）Java8 Optional 类

Optional 类主要解决的问题是臭名昭著的空指针异常（NullPointerException）。
本质上，这是一个包含有可选值的包装类，这意味着 Optional 类既可以含有对象也可以为空。

例如：

String isocode = user.getAddress().getCountry().getIsocode().toUpperCase();

在 Java 8 之前，任何访问对象方法或属性的调用都可能导致 NullPointerException
在这个小示例中，如果我们需要确保不触发异常，就得在访问每一个值之前对其进行明确地检查：

if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        Country country = address.getCountry();
        if (country != null) {
            String isocode = country.getIsocode();
            if (isocode != null) {
                isocode = isocode.toUpperCase();
            }
        }
    }
}

容易造成代码冗长难以维护。

API

序号	方法 & 描述
1	static Optional empty() 返回空的 Optional 实例。
2	boolean equals(Object obj) 判断其他对象是否等于 Optional。
3	Optional filter(Predicate<? super predicate) 如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
4	<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper) 如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional。
5	T get() 如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException。
6	int hashCode() 返回存在值的哈希码，如果值不存在 返回 0。
7	void ifPresent(Consumer<? super T> consumer) 如果值存在则使用该值调用 consumer , 否则不做任何事情。
8	boolean isPresent() 如果值存在则方法会返回true，否则返回 false。
9	<U>Optional<U> map(Function<? super T,? extends U> mapper) 如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空Optional。
10	static Optional of(T value) 返回一个指定非null值的Optional。
11	static Optional ofNullable(T value) 如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。
12	T orElse(T other) 如果存在该值，返回值， 否则返回 other。
13	T orElseGet(Supplier<? extends T> other) 如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。
14	T orElseThrow(Supplier<? extends X> exceptionSupplier) 如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常
15	String toString() 返回一个Optional的非空字符串，用来调试。

源码

• static Optional empty()：返回内容为空的Optional

    /**
     * Common instance for {@code empty()}.
     */
    private static final Optional<?> EMPTY = new Optional<>();

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

• boolean equals(Object obj)：重写Object的equals方法，obj必须是Optional类型，然后判断两个Optional容器中的值进行Objects.equals判断。

    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);
    }

    //Objects.equals(Object a, Object b)
    public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }

• Optional filter(Predicate<? super predicate)：如果容器中value值为null返回当前Optional（即值为null的Optional），若test()方法为true返回当前value不为空的Optional，为false返回EMPTY = new Optional<>()（值为空的Optional）

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

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

• Optional<U> flatMap(Function<? super T, Optional<U>> mapper)： 提取mapper.apply(value)方法返回的值

    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));
        }
    }

• T get()：若容器value值不为null则返回value值，否则抛出异常

    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

• void ifPresent(Consumer<? super T> consumer)：若容器中value不为null则进行accept(value)自定义操作。

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

• boolean isPresent()：容器中value值是否为null

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

• Optional<U> map(Function<? super T, ? extends U> mapper)：

    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));
        }
    }

• static Optional of(T value)：创建一个新的Optional。value参数不能为null，否则抛出异常

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

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

• static Optional ofNullable(T value)：创建一个新的Optional。value参数可以为null，为null时返回EMPTY = new Optional<>()值为空的Optional

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

• T orElse(T other)：容器中value值为null则返回默认的 other值

    public T orElse(T other) {
        return value != null ? value : other;
    }

• T orElseGet(Supplier<? extends T> other)：容器中value值为null则返回默认的 other.get()值

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

    //Supplier get()
    T get();

• T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X：容器中value值为null则抛出指定异常

    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

参考：https://blog.csdn.net/xhd731568849/java/article/details/79532959