java 8 Optional的使用

2019独角兽企业重金招聘Python工程师标准>>>

1、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";
    }
}

2、创建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);

3、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 接口生成的异常

4、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 + " 的用户没有找到"));

 

转载于:https://my.oschina.net/u/563488/blog/1612128