Java Optional 类

Optional类是null值得容器，可以保存类型为T的泛型的值或null，很好的解决了空值的包装问题。

先看源码（去掉原始注释，减少阅读量），源代码比一堆文字解释更清晰

public final class Optional<T> {
  
    private static final Optional<?> EMPTY = new Optional<>();

    private final T value;
    
    //私有方法，内部使用
    private Optional() {
        this.value = null;
    }

    //私有方法，内部使用
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    
    //部分源代码在下面
    ...
}

对象初始化

• of
• ofNullable

    //静态初始化方法，直接返回空对象
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
    //静态初始化方法，value必须非空，返回Optional对象
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    //静态初始化方法，value可以为空，返回Optional对象
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

判断值是否存在

• ifPresent
• ifPresent(Consumer…)

    //判断value是否存在
    public boolean isPresent() {
        return value != null;
    }
    //如果value存在，则执行入参中的消费型函数体
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

获取值

• get
• orElse
• orElseGet

    //获取对象中value，如果为空，则抛错
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
    
    //如果value为空，则返回入参作为默认值
    public T orElse(T other) {
        return value != null ? value : other;
    }
    //如果value为空，则返回入参供应型函数的返回值
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }
    //如果value为空，则抛出入参供应型函数指定的异常
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

链式处理

• filter
• map
• flatMap

    //根据入参predicate函数过滤值，返回Optional对象可链式处理
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }
    //执行入参function函数体，返回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));
        }
    }
    //执行入参Function函数体，要求入参函数返回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 class FunctionTest {
    public static void main(String[] args) throws Exception {

        Integer v1 = null;
        Integer v2 = new Integer(2);
        
        //如果不确定V1是否为空，可以使用ofNullable方法
        Optional<Integer> o1 = Optional.ofNullable(v1);
        
        //明确v2有值，则可以使用of方法
        Optional<Integer> o2 = Optional.of(v2);
        
        //o1如果值不存在则赋默认值0，并参与计算
        System.out.println(o1.orElse(0) + o2.get()); // 2

        //o2如果值存在，则执行一段逻辑代码
        o2.ifPresent(System.out::println); // 2
        
        //o1如果不存在，则用函数生成随机数 
        System.out.println(o1.orElseGet(() -> (int) (Math.random() * 1000))); // 59
        
        //o1如果值不存在，则抛指定的异常
        o1.orElseThrow(Exception::new); // throw new Exception();
    }
}