// 1、创建出一个Optional容器，容器里边并没有装载着对象
    private static final Optional<?> EMPTY = new Optional<>();
    // 2、代表着容器中的对象
    private final T value;
    // 3、私有构造方法
    private Optional() {
        this.value = null;
    }
    // 4、得到一个Optional容器，Optional没有装载着对象
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
    // 5、私有构造方法(带参数)，参数就是具体的要装载的对象，如果传进来的对象为null，抛出异常
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    // 5.1、如果传进来的对象为null，抛出异常
    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }
    // 6、创建出Optional容器，并将对象(value)装载到Optional容器中。
    // 传入的value如果为null，抛出异常(调用的是Optional(T value)方法)
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    // 创建出Optional容器，并将对象(value)装载到Optional容器中。
    // 传入的value可以为null，如果为null，返回一个没有装载对象的Optional对象
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
复制代码

// 得到容器中的对象，如果为null就抛出异常
public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}
// 判断容器中的对象是否为null
public boolean isPresent() {
    return value != null;
}
// 如果容器中的对象存在，则返回。否则返回传递进来的参数
public T orElse(T other) {
    return value != null ? value : other;
}
复制代码

public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
        consumer.accept(value);
}
@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}
复制代码

// 如果对象存在，则直接返回，否则返回由Supplier接口的实现用来生成默认值
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}
@FunctionalInterface
public interface Supplier<T> {
    T get();
}
// 如果存在，则返回。否则抛出supplier接口创建的异常
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}
复制代码

public static void main(String[] args) {
    User user = new User();
    user.setName("六脉神剑");
    test(user);
}
public static void test(User user) {
    Optional<User> optional = Optional.ofNullable(user);
    // 如果存在user，则直接返回，否则创建出一个新的User对象
    User user1 = optional.orElseGet(() -> new User());
    // 旧写法
    if (user != null) {
        user = new User();
    }
}
复制代码

// 如果容器中的对象存在，并且符合过滤条件，返回装载对象的Optional容器，否则返回一个空的Optional容器
public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent())
        return this;
    else
        return predicate.test(value) ? this : empty();
}
// 接口
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}
复制代码

public static void test(User user) {
    Optional<User> optional = Optional.ofNullable(user);
    // 如果容器中的对象存在，并且符合过滤条件，返回装载对象的Optional容器，否则返回一个空的Optional容器
        Optional<User> optional = Optional.ofNullable(user);
        User user1 = optional.filter((value) -> "六脉神剑".equals(value.getName())).orElse(null);
        System.out.println(user1.getName());
}
复制代码

// 如果容器的对象存在，则对其执行调用mapping函数得到返回值。然后创建包含mapping返回值的Optional，否则返回空Optional。
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));
    }
}
// 接口
@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}
复制代码

public static void test(User user) {
    Optional<User> optional = Optional.ofNullable(user);
    // 如果容器的对象存在，则对其执行调用mapping函数得到返回值。然后创建包含mapping返回值的Optional，否则返回空Optional。
    optional.map(user1 -> user1.getName()).orElse("六脉神剑");
}
// 上面一句代码对应着最开始的老写法：
public String tradition(User user) {
    if (user != null) {
        return user.getName();
    }else{
        return "六脉神剑";
    }
}
复制代码

// flatMap方法与map方法类似，区别在于apply函数的返回值不同。map方法的apply函数返回值是? extends U，而flatMap方法的apply函数返回值必须是Optional
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 static void main(String[] args) {
    User user = new User();
    user.setName("六脉神剑");
    System.out.println(test(user));
}
// 以前的代码1.0
public static String test2(User user) {
    if (user != null) {
        String name = user.getName();
        if (name != null) {
            return name.toUpperCase();
        } else {
            return null;
        }
    } else {
        return null;
    }
}
// 以前的代码2.0
public static String test3(User user) {
    if (user != null && user.getName() != null) {
        return user.getName().toUpperCase();
    } else {
        return null;
    }
}
// 现在的代码
public static String test(User user) {
    return Optional.ofNullable(user)
            .map(user1 -> user1.getName())
            .map(s -> s.toUpperCase()).orElse(null);
}
复制代码