Java 8 新特性之Optional 类方法大全

Optional 类是可以为null的容器对象。类里有很多方法，这样我们就不用显式进行空值检测，避免空指针异常。
empty：返回空的 Optional 实例。

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

of：返回一个指定非null值的Optional实例。

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

ofNullable：如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional实例。

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

get：如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException

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

isPresent：如果值存在则方法会返回true，否则返回 false。

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

ifPresent：如果值存在则使用该值调用 consumer , 否则不做任何事情。

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

filter：如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。

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

map：如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空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));
        }
    }

flatMap:如果值存在，返回基于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));
        }
    }

orElse：如果存在该值，返回值， 否则返回 other。

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

orElseGet：如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。

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

orElseThrow：如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常

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

equals：判断其他对象是否等于 Optional。

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

hashCode：返回存在值的哈希码，如果值不存在 返回 0。

    @Override
    public int hashCode() {
        return Objects.hashCode(value);
    }

toString：返回一个Optional的非空字符串，用来调试。

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