Optional静态类( Java8 )

Optional简介

在Java8中的StreamAPI有很多操作都返回了Optional对象，那么这个对象是用来干嘛的，用来解决空指针问题，产生的一个类。也可以认为这是一个容器对象，因为它可以保存类型为T的对象，也可以保存null

Optional类源码

import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
 
public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional<>();
 
    private final T value;
 
    private Optional() {
        this.value = null;
    }
 
    public static <T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
 
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
 
    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);
    }
 
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
 
    public boolean isPresent() {
        return value != null;
    }
 
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }
 
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }
 
    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));
        }
    }
 
    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;
    }
 
    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();
        }
    }
 
    @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";
    }
}

创建Optional类

该类创建对象的方法被私有化了，所以不能直接创建该对象，提供了三个静态方法创建实例对象

    private Optional() {
        this.value = null;
    }
 
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    // 1.直接返回类加载后，就创建的空对象
    public static <T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
    // 2.直接new一个Optional对象
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    // 3.判断是否为null，是直接返回类加载后，就创建的空对象，否则直接new一个对象
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);

获取泛型对象的方法

    // 1. 直接获取，如果为null，则抛出异常
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
    // 2. 获取对象时，设置一个默认值进行获取，如果为null，则返回默认值
    public T orElse(T other) {
        return value != null ? value : other;
    }
    // 3. 与第2个方式相同，只是该方法的参数是函数式参数
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }
    // 4. 与第1个方式相同，但可以返回特定的异常
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

Optional类的其他方法

    // 1. 判断值是否为null
    public boolean isPresent() {
        return value != null;
    }
    // 2. 如果值不为空，对值做一些特定操作
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }
    // 3. 筛选符合规则的对象
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }
    // 4. 改变对象的类型,然后返回
    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));
        }
    }
    // 5. 合并相同对象类型,然后返回
    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));
        }
    }

文章借鉴处

• https://blog.csdn.net/qq_28410283/article/details/80952768