java8 - Optional

在开发过程中，我们经常遇到NullPointerException，为了避免NullPointerException这个异常，我们经常要在代码里判断非空，导致代码膨胀，影响了可读性。为此Java 8中引入了一个新的类java.util.Optional<T>，这是一个封装Optional值的类，来处理有可能为空的情况。
Optional有两个成员对象，一个是EMPTY，一个是value。EMPTY是Optional类型的，value是T泛型。

empty

创建一个空的Optional。
从源码可以看中，这个value是为null。

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

private static final Optional<?> EMPTY = new Optional<>();

private Optional() {
    this.value = null;
}

of

通过指定的值创建Optional，从源码可以看出，有判断非空，所以这个方法如果传递过来的是null，会抛NullPointerException异常。

public static <T> Optional<T> of(T value) {
    return new Optional<>(value);
}
private Optional(T value) {
    this.value = Objects.requireNonNull(value);
}

ofNullable

如果允许接受一个为空的Optional，就可以用ofNullable。从源码可以看出，如果是为空，就调用empty方法，如果不为空，调用of方法。

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

isPresent

判断value是否为空，不为空返回true，为空返回false

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

map

把指定对象映射后返回Optional。
从源码可以看出，先判断mapper是否为空，为空抛出异常。不为空，再判断value是否为空，为空，直接返回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));
    }
}

flatMap

类似map，不同的是返回的是Optional类型，多层封装对象的时候可以用这个方法，比如有个Person类，Person有个child成员变量，也是Person对象，可以这样获取person的name，optPerson.flatMap(Person::getOptChild).map(Person::getName)。

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

get

返回Optional的value，如果value为空，抛出NoSuchElementException异常。

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

orElse

如果value不为空，返回value，否则返回默认值

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

orElseGet

这个跟orElse类似，只是为空的时候，返回的是Supplier的get方法。

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

orElseThrow

如果value为空，则抛异常，这个异常是有传过来的Supplier的get指定的。

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

ifPresent

如果value存在，则调用Consumer的accept方法。

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

filter

如果存在且满足Predicate的test方法，返回当前的Optional，否则返回空的Optional对象

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