0x00 Optional简介

Optional是一个基于值的类，一般用于规避NullPointException的，作为一个容器对象，Optional内部包含一个可能为空的值，这个值如果非空，则内部isPresent()将返回true，其他方法可以基于函数式编程来操作这个值。

Optional使用主要是为了提升代码的健壮性，已经在多种语言中流行

0x01 构造方法

Optional有3种构造方法，分别应对了3种情况。

/**
 * 已知对象的值为空，则使用 empty() 创建Optional对象
 */
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
/**
 * 已知对象的值一定不为空，则使用 of() 创建Optional对象
 */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
/**
 * 当对象的值无法预料是否为空时，则使用 ofNullable() 创建Optional对象
 */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

0x02 方法源码

    /**
     * 如果只存在，返回Optional包装的值，否则返回NoSuchElementException异常
     */
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

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

    /**
     * 基于函数式编程，如果值不为空，则将这个值交给Consumer去执行内部accept方法
     */
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

    /**
     * 过滤Optional中的值，传入一个验证方法，如果符合验证则值继续存在，否则将Optional存储的值清空为null
     */
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

    /**
     * 将Optional中的值进行转换或操作修改，这个修改行为由Function内的apply去执行，可以视为Lambda表达式，操作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));
        }
    }

    /**
     * 一般跟在map或filter方法之后，当Optional储存值不为空时，返回储存值，否则返回orElse(T other)，提供的默认值。
     */
    public T orElse(T other) {
        return value != null ? value : other;
    }

    /**
     * 类似orElse方法，不一样的是这里传入的是Supplier，可以转换成Lambda表达式，提供其他的值或运算结果。
     */
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

0x03使用方式举例

看完源码，就应该实际操作一下
不辞辛苦型

        Optional<String> op = Optional.ofNullable(null);
        if(op.isPresent()){
            System.out.println(op.get());
        }else {
            System.out.println("Optional.empty");
        }

初级使用

        Optional<String> op = Optional.ofNullable("hello");
        op.ifPresent(System.out::println);

运行结果

进阶使用

 Optional<String> op = Optional.ofNullable(null);
 System.out.println(
          op.filter(item -> item.length() > 0)
            .map((item) -> item + " world!")
            .orElse("nice to meet you!")
);