Optional-java8特性

使用场景：

1. 结合lambda表达式使用；
2. 将返回值元素放进Optional<T>中；

重要方法：

1.Optional的 构造函数全部私有，因此获取起实例只能根据三个方法of(obj)、empty()和ofNullable(obj)获取，如函数名所示，三个方法分别返回有元素实例，无元素实例和和可能当无元素的实例。obj为null时，创建实例采用了单例模式，节省内存。具体即解释如下：

  /**
     * 空实例，单例模式
     * Common instance for {@code empty()}.
     */
    private static final Optional<?> EMPTY = new Optional<>();

    //构造函数都是私有的，实例都用of()、ofNullable()和empty()则三个方法获取；
    /**
     * <p>无参私有构造参数</p>
     */
    private Optional() {
        this.value = null;
    }

    /**
     * <p>私有构造器，用已有的value值构造实例</p>
     */
    private Optional(T value) {
        // Objects.requireNonNull(obj):如果是null抛异常，不是则不作处理返回；
        this.value = Objects.requireNonNull(value);
    }

    /**
     * <p>调用有参私有构造器，参数为null则抛空指针异常</p>
     */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    /**
     * <p>返回不包括任何元素的实例</p>
     */
    public static<T> Optional<T> empty() {
        //private static final Optional<?> EMPTY = new Optional<>();类开始的EMPTY用私有无参构造函数赋值
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    /**
     * <p>可能返回不包含元素的实例，允许参数为null</p>
     */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

2.元素是否存在，以及存在与否这两种情况，需要进行大致四种方式的处理， 不同的情况对应着不同的函数，乱用则可能造成代码冗长

1）存在这对元素进行处理，对应t.ifPresent方法，不存在则什么都不返回；

2）存在则返回，不存在则返回默认值，对应orElse(常量var)方法；

3）存在则返回，不存在则由相应函数产生，对应orElseGet(Lambda表达式, Supplier); 

4）不存在抛异常；orElseThrow(XX);

【注】涉及到包 java.util.function下的类，@ FunctionalInterface注解的用法

 

    /**
     *存在则处理，不准在什么都不做
     */
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

    /**
     * Optional包含元素则返回元素，不包含元素则返回orElse(obj)的参数obj;
     */
    public T orElse(T other) {
        return value != null ? value : other;
    }

    /**
     * Optional包含元素则返回元素，不包含元素则调用参数的get()方法，返回其值
     * 参数可以是lambda表达式，如:
     *      t.orElseGet(()->eleGetter()));
     */
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

    /**
     * 无元素则抛IllegalArgumentException或及其子类异常，示例：
     *
     *  t.orElseThrow(()->new IllegalArgumentException("description for Exception");
     *
     */
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }


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

其他

5）对元素进行过滤；filter(Lambda);

6） public < U > Optional< U >map(Function<? super T , ? extends U > mapper)：如果Optional包含元素，则调用函数得到返回值-用Optional包装后返回，可以为Optional(null);如果Optional不包含元素则抛空指针异常。因为返回值是Optional，因此map(XX)可以无限调用下去；

    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));
	   //return Objects.requireNonNull(mapper.apply(value)); flatmap方法 
 } }