Optional

Optional类是一个用来存放值的容器对象，如果值存在则isPresent()方法返回true，调用get()方法会返回该值 Optional类用来在一定程度上避免NPE(NullPointerException)问题 Optional类拥有一个value属性专门用来存放值，其构造方法均私有化，不能由外部调用，其内部还维护了一个value为null的EMPTY对象

Java9为Optional类增加了三个方法：or()、ifPresentOrElse()和stream()。or()方法与orElse()和orElseGet()类似，都是在value值为null的时候提供了替代情况，or()的返回值是由Supplier接口类型的变量产生的一个新的Optional对象。ifPresentOrElse()方法需要两个参数，一个Consumer和一个Runnable，如果对象包含值，会执行Consumer的动作，否则运行Runnable。stream()方法是把对象转换为Stream对象，如果没有值，得到空的Stream，否则，Stream包含单一值。

基础数据：

@Data
static class User{ private String name; }

@Data
static class User2{
    private String name;

    public Optional<String> getName() {
        return Optional.ofNullable(name);
    }
}

private static User createUser(){
    User user = new User();
    user.setName("xyz");
    return user;
}

private static User2 createUser2(){
    User2 user = new User2();
    user.setName("dyzr");
    return user;
}

Optional(T value)、empty()、of(T value)、ofNullable(T value)

Optional(T value)：即构造函数，它是private权限的，不能由外部调用。其余三个函数是public权限的，可由外部调用。

private Optional(T value) {
    this.value = Objects.requireNonNull(value);
}

of(T value)：该函数内部调用了有参构造函数，当value值不为空时，能正常构造Optional对象，当value值为空时，依然会报空指针异常

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

empty()：该函数的作用就是返回Optional类中的EMPTY对象

private static final Optional<?> EMPTY = new Optional<>();

private Optional() {
    this.value = null;
}

public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}

ofNullable(T value)：相较于of(T value)，当value值为null时，直接返回Optional类中的EMPTY对象

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

使用案例：

Optional<User> optionalUser1 = Optional.empty();
System.out.println("optionalUser1 = " + optionalUser1);
User user = createUser();
Optional<User> optionalUser2 = Optional.of(user);
System.out.println("optionalUser2 = " + optionalUser2);
User2 user2 = null;
Optional<User2> optionalUser3 = Optional.ofNullable(user2);
System.out.println("optionalUser3 = " + optionalUser3);

orElse(T other)、orElseGet(Suppliser<? extends T> other)、orElseThrow(Suppliser<? extends X> exceptionSupplier)

这三个函数都是在构造函数传入的value值为null时进行调用 orElse和orElseGet函数是在value值为null时，给予一个默认值。orElse和orElseGet函数区别在于无论value值是否为null，orElse函数都会执行，而当value值不为null时，orElseGet函数不会执行 orElseThrow函数是在value值为null时，直接抛出一个异常

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();
    }
}

使用案例：

User user = null;
user = Optional.ofNullable(user).orElse(createUser());
System.out.println("user1:" + user);
user = Optional.ofNullable(user).orElseGet(() -> createUser());
System.out.println("user2:" + user);
User user2 = null;
user2 = Optional.ofNullable(user2).orElseThrow(() -> new Exception("user为空!"));
System.out.println("user3:" + user2);

map(Function<? super T, ? extends U> mapper)和flatMap(Function<? super T, Optional> mapper)

这两个函数做的是值转换的操作，区别是函数的入参不同

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));
    }
}

使用案例：

User user = createUser();
String name = Optional.ofNullable(user).map(u -> u.getName()).get();
System.out.println("username:" + name);
User2 user2 = createUser2();
String name2 = Optional.ofNullable(user2).flatMap(u -> u.getName()).get();
System.out.println("username:" + name2);

isPresent()和ifPresent(Consumer<? super T> consumer)

isPresent函数判断value值是否为空，不为空返回true，为空返回false ifPresent函数在value值不为空时，做一些指定的操作

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

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

使用案例：

User user = null;
boolean result = Optional.ofNullable(user).isPresent();
System.out.println("result:" + result);
User user2 = createUser();
Optional.ofNullable(user2).ifPresent(System.out::println);
User2 user3 = createUser2();
Optional.ofNullable(user3).ifPresent(System.out::println);

filter(Predicate<? super T> predicate)

filter函数接收一个Predicate接口类型的变量对Optional中包含的值进行过滤，如果值满足条件，则返回该Optional，否则返回Optional.empty

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

使用案例：

User user = createUser();
Optional<User> optionalUser = Optional.ofNullable(user).filter(u -> u.getName().length() > 6);
System.out.println("optionalUser:" + optionalUser);
User2 user2 = createUser2();
Optional<User2> optionalUser2 = Optional.ofNullable(user2).filter(u -> u.getName().get().length() < 6);
System.out.println("optionalUser2:" + optionalUser2);

实战示例

在函数方法中

User user = null;
//java7及之前写法
if(user != null){
    if(user.getName() != null){
        //todo something
    }
}else{
    throw new Exception("user对象为空!");
}
//java8写法
Optional.ofNullable(user)
    .map(User::getName)
    .orElseThrow(() -> new Exception("user对象为空!"));

在主程序中

User user = null;
//java7及之前写法
if(user != null){
    //todo something
}
//java8写法
Optional.ofNullable(user)
    .ifPresent(u -> { 
        //todo something 
    });

在函数方法中

User user = null;
//java7及之前写法
if(user != null){
    String name = user.getName();
    if ("xxx".equals(name)) {
        //todo something
    }
}else{
    //todo something
}
//java8写法
Optional.ofNullable(user)
    .filter(u -> "xxx".equals(u.getName()))
    .orElseGet(() -> {
        //todo something
    });