java8--Optional

大纲：

1. 简介
2. 成员变量、构造函数
3. 主要方法

一、简介：

Optional是一个容器，可以存放任意值和null。

可以通过get方法拿到Optional对象中存放的值。

二、成员变量、构造函数

Optional成员变量（只有2个）：

    /**
     * 空的Optional对象，empty方法返回这个对象。
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * Optional中存放的值
     */
    private final T value;

Optional构造函数（私有，不允许外部直接创建）：

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

三、主要方法

• empty

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

返回一个存放null值得optional

• isPresent

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

返回存放的值是否为null

• ifPresent

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

如果值存在则执行consumer函数

• of&ofNullable

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

of方法调用构造函数创建optional对象，但是构造函数中当传入的值为null时会抛出空指针异常。

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

ofNullable则允许传入null值。

• get&orElse&orElseGet

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

返回存放的值

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

返回存放的值，当值为空时，返回指定的值other。

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

和orElse一样返回存放的值，当值为空时，返回指定的值，这个指定值是other函数的返回值。

• filter

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

值存在且符合predicate规则，则返回这个optional对象，否则返回值为null的optional对象。

• map&flatMap

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

值存在则按照mapper函数将值处理好后包装一个optional对象并返回，否则返回值为null的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));
        }
    }

与map方法类似，区别在于flatMap的mapper函数处理好的返回值必须为一个已经包装好的optional对象。