Optional详解

1、初始化方法说明：ofNullable(T value)、of(T value)、empty()

ofNullable(T value)

• 允许传递一个为null的值，是null的话调用empty()方法，否则调用of(T value)方法

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

of(T value)

• 不允许传递null值，否则会抛出异常NullPointerException，将T值调用构造方法赋值给value

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

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

empty()

• 生成一个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<>();
    
    // 无参构造直接设置value=null
    private Optional() {
        this.value = null;
    }

2、功能方法说明

isPresent()

• // 判断是否为null，不为null返回true

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

ifPresent()

• 值不为null，则进入ifPresent方法，执行输入的函数

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

orElse

• 值为null，返回orElse的参数，否则返回原值

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

orElseGet

• 值为null，进入orElse中接收的函数，返回函数的返回值（和orElse比较：返回值一样，但是函数中可以做一些其他的操作）。

    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }
    // 函数式接口，无参，有返回值
    @FunctionalInterface
    public interface Supplier<T> {

	   /**
	    * Gets a result.
	    *
	    * @return a result
	    */
	   T get();
    }

orElseThrow

• 值为null，进入orElse中接收的函数，抛出函数中自定义的异常。

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

3、实际应用

• 举个例子，在用Stream流筛选list中的数据时，期望只得到一个结果，最终会有3种处理方式

方法1

    public String get(){
        List<String> strings = Arrays.asList("a", "b", "c");
        List<String> d = strings.stream().filter(e -> e.equals("d")).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(d)){
            // 异常的处理逻辑，或return null，或抛出异常，或 return 自定义的值
            return "没找到，自定义一个值";
        }else {
            return d.get(0);
        }
    }

方法2

    public String get(){
        List<String> strings = Arrays.asList("a", "b", "c");
        Optional<String> d = strings.stream().filter(e -> e.equals("d")).findFirst();
        if (d.isPresent()){
            return d.get();
        }else {
            // 异常的处理逻辑，或return null，或抛出异常，或 return 自定义的值
            return "没找到，自定义一个值";
        }
    }

方法3

    public String get() {
        List<String> strings = Arrays.asList("a", "b", "c");
        return strings.stream().filter(e -> e.equals("d")).findFirst().orElse("没找到，自定义一个值");
    }

4、总结

从代码清晰度以及执行的流程，肯定第三种是最推荐的