JDK8中使用设计模式装饰器模式新建一个类，使用 JDK9 中Optional的新特性

实际开发中，我们的JDK版本一般不会轻易变动，如果JDK版本是 8 的话，又想使用 JDK9 中的 Optional 新特性，那么可以使用以下方法来实现。

主要利用设计模式装饰器模式包装原始的 Optional 类。如果是JDK8 原始的方法直接委托运行，JDK9 中的新特性则直接重新编写接口加入到这个包装类中即可。
这样就可以无缝衔接 Optional 类，使用起来没有什么差异。
为了和原生 Optional 类一样强大，还需要了解 Java 泛型的上下界，写出合适的泛型方法。

实现的代码为：

public class OptionalWrapper<T> {  
  
    private Optional<T> optional;  
    private T value;  
  
    private OptionalWrapper(Optional<T> optional, T value) {  
        this.optional = optional;  
        this.value = value;  
    }  
  
    public static <T> OptionalWrapper<T> of(T value) {  
        Optional<T> optional = Optional.of(value);  
        return new OptionalWrapper<>(optional, value);  
    }  
  
    public static <T> OptionalWrapper<T> empty() {  
        Optional<T> optional = Optional.empty();  
        return new OptionalWrapper<>(optional, null);  
    }  
  
    public static <T> OptionalWrapper<T> ofNullable(T value) {  
        Optional<T> optional = Optional.ofNullable(value);  
        return new OptionalWrapper<>(optional, value);  
    }  
  
    public T get() {  
        return this.optional.get();  
    }  
  
    public boolean isPresent() {  
        return this.optional.isPresent();  
    }  
  
    public void ifPresent(Consumer<? super T> consumer) {  
        this.optional.ifPresent(consumer);  
    }  
  
    public OptionalWrapper<T> filter(Predicate<? super T> predicate) {  
        Optional<T> optional = this.optional.filter(predicate);  
        return optional.isPresent() ? this : empty();  
    }  
  
    public <U> OptionalWrapper<U> map(Function<? super T, ? extends U> mapper) {  
        Optional<? extends U> optional = this.optional.map(mapper);  
        return optional.isPresent() ? OptionalWrapper.ofNullable(optional.get()) : OptionalWrapper.empty();  
    }  
  
    public <U> OptionalWrapper<U> flatMap(Function<? super T, OptionalWrapper<U>> mapper) {  
        Objects.requireNonNull(mapper);  
        return this.optional.isPresent() ? Objects.requireNonNull(mapper.apply(value)) : empty();  
    }  
  
    public T orElse(T other) {  
        return this.optional.orElse(other);  
    }  
  
    public T orElseGet(Supplier<? extends T> other) {  
        return this.optional.orElseGet(other);  E
    }  
  
    public <X extends Throwable> T orElseThrow(Supplieer<? extends X> exceptionSupplier) throws X {  
        return this.optional.orElseThrow(exceptionSupplier);  
    }  

// 如果存在就执行指定的动作，不存在则执行另一个动作
    public void ifPresentOrElse(Consumer<T> action, Runnable emptyAction) {  
        Objects.requireNonNull(emptyAction);  
        if (this.optional.isPresent()) {  
            action.accept(value);  
        } else {  
            emptyAction.run();  
        }  
    }  
  
    public Stream<T> stream() {  
        return map(Stream::of).orElseGet(Stream::empty);  
    }  

// 如果只存在，就返回一个 Optional，否则返回另一个提供的Optional
// 与 orElse 的区别是 orElse 返回一个没有包装的实例，这个返回包装的实例
    public OptionalWrapper<T> or(Supplier<? extends OptionalWrapper<? extends T>> supplier) {  
        Objects.requireNonNull(supplier);  
        return optional.isPresent() ? this : supplier.get().map(Function.identity());  
    }  
}