Java——Optional类详解

前言

Optional 是一个对象容器，具有以下两个特点：

• 提示用户要注意该对象有可能为null
• 简化if else代码

使用

1. 创建：

Optional.empty()： 创建一个空的 Optional 实例

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

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

Optional.of(T t)：创建一个 Optional 实例，当 t为null时抛出异常

private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    
public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

Optional.ofNullable(T t)：创建一个 Optional 实例，但当 t为null时不会抛出异常，而是返回一个空的实例

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

2. 获取：

get()：获取optional实例中的对象，当optional 容器为空时报错

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

3. 判断：

isPresent()：判断optional是否为空，如果空则返回false，否则返回true

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

ifPresent(Consumer c)：如果optional不为空，则将optional中的对象传给Comsumer函数

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

orElse(T other)：如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个默认值

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

orElseGet(Supplier other)：如果optional不为空，则返回optional中的对象；如果为null，则使用Supplier函数生成默认值other

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

orElseThrow(Supplier exception)：如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常

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

4. 过滤：

filter(Predicate p)：如果optional不为空，则执行断言函数p，如果p的结果为true，则返回原本的optional，否则返回空的optional

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

5. 映射：

map(Function<T, U> mapper)：如果optional不为空，则将optional中的对象 t 映射成另外一个对象 u，并将 u 存放到一个新的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(Function< T,Optional> mapper)：跟上面一样，在optional不为空的情况下，将对象t映射成另外一个optional
区别：map会自动将u放到optional中，而flatMap则需要手动给u创建一个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));
        }
    }

demo举例

暂无