java 8 Optional的使用

一、Optional源码

package java.util;

import ......

public final class Optional < T > {

    private static final Optional << ? > EMPTY = new Optional < > ();
    private final T value;
    private Optional() {
        this.value = null;
    }
    public static < T > Optional < T > empty() {
        @SuppressWarnings("unchecked")
        Optional < T > t = (Optional < T > ) EMPTY;
        return t;
    }
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    public static < T > Optional < T > of (T value) {
        return new Optional < > (value);
    }
    public static < T > Optional < T > ofNullable(T value) {
        return value == null ? empty() : of (value);
    }
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }
    public boolean isPresent() {
        return value != null;
    }
    public void ifPresent(Consumer << ? super T > consumer) {
        if (value != null)
            consumer.accept(value);
    }
    public Optional < T > filter(Predicate << ? super T > predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }
    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));
        }
    }
    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 T orElse(T other) {
        return value != null ? value : other;
    }

    public T orElseGet(Supplier << ? extends T > other) {
        return value != null ? value : other.get();
    }
    public < X extends Throwable > T orElseThrow(Supplier << ? extends X > exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof Optional)) {
            return false;
        }

        Optional << ? > other = (Optional << ? > ) obj;
        return Objects.equals(value, other.value);
    }
    @Override
    public int hashCode() {
        return Objects.hashCode(value);
    }
    @Override
    public String toString() {
        return value != null ?
            String.format("Optional[%s]", value) :
            "Optional.empty";
    }
}

二、建立Optional对象

//声明一个空的Optional
Optional<Car> optCar = Optional.empty();

/**
*依据一个非空值建立Optional.
*若是car是一个null，这段代码会当即抛出一个NullPointerException，而不是等到你 试图访问car的属性值时才返回一个错误
*/
Optional<Car> optCar = Optional.of(car)

//可接受null的Optional
 Optional<Car> optCar = Optional.ofNullable(car);

三、Optional类的方法列举和简单描述

方法	描述
empty	返回一个空的 Optional 实例
filter	若是值存在而且知足提供的谓词，就返回包含该值的 Optional 对象;不然返回一个空的 Optional 对象
flatMap	若是值存在，就对该值执行提供的 mapping 函数调用，返回一个 Optional 类型的值，不然就返回一个空的 Optional 对象
get	若是该值存在，将该值用 Optional 封装返回，不然抛出一个 NoSuchElementException 异常
ifPresent	若是值存在，就执行使用该值的方法调用，不然什么也不作
isPresent	若是值存在就返回 true，不然返回 false
map	若是值存在，就对该值执行提供的 mapping 函数调用
of	将指定值用 Optional 封装以后返回，若是该值为 null，则抛出一个 NullPointerException 异常
ofNullable	将指定值用 Optional 封装以后返回，若是该值为 null，则返回一个空的 Optional 对象
orElse	若是有值则将其返回，不然返回一个默认值
orElseGet	若是有值则将其返回，不然返回一个由指定的 Supplier 接口生成的值
orElseThrow	若是有值则将其返回，不然抛出一个由指定的 Supplier 接口生成的异常

四、Optional类的方法举例

1.ifPresent

Optional<User> user = Optional.ofNullable(getUserById(id));
user.ifPresent(u -> System.out.println("Username is: " + u.getUsername()));

2.orElse

若是 Optional 中有值则将其返回，不然返回 orElse 方法传入的参数。

User user = Optional
        .ofNullable(getUserById(id))
        .orElse(new User(0, "Unknown"));
        
System.out.println("Username is: " + user.getUsername());

3.orElseGet

orElseGet 与 orElse 方法的区别在于，orElseGet 方法传入的参数为一个 Supplier 接口的实现 —— 当 Optional 中有值的时候，返回值；当 Optional 中没有值的时候，返回从该 Supplier 得到的值。

User user = Optional
        .ofNullable(getUserById(id))
        .orElseGet(() -> new User(0, "Unknown"));
        
System.out.println("Username is: " + user.getUsername());

4.orElseThrow

orElseThrow 与 orElse 方法的区别在于，orElseThrow 方法当 Optional 中有值的时候，返回值；没有值的时候会抛出异常，抛出的异常由传入的 exceptionSupplier 提供。

User user = Optional
        .ofNullable(getUserById(id))
        .orElseThrow(() -> new EntityNotFoundException("id 为 " + id + " 的用户没有找到"));