一、简介

Optional类是Java 8中引入的一个用于处理null值的容器类。它封装了某个类型的值，这个值可以是null，也可以是非null，通过它可以更优雅和简洁地处理包含null值的对象。
Optional类的官方描述：

A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value.

翻译过来就是：

一个可能包含null值的容器对象。如果值存在，isPresent()方法将会返回true，get()方法将会返回该值。

二、特点

Optional 类是一个容器类，用于保存可能为 null 的对象；
Optional 实例提供了一些方法，能够更好地检测非空值以及在值为 null 的情况下提供替代值的方式；
Optional 类是不可变的，即一旦创建了 Optional 实例，就不能改变该实例的值（除非初始化时的值为 null）；
Optional 类的最终目的是避免 NullPointerException 异常，从而提升代码的健壮性。

三、工厂方法

Optional的提供了三个工厂方法用于创建对象，empty( )、of( )、ofNullable( )

//构造一个空的Optional对象
Optional.empty();

//构造一个Optional对象,入参必须不会空,如果入参是空,就抛出空指针异常
Optional.of(T value);

//构造一个Optional对象,入参可以是空,如果入参是空,就返回Optional.empty()
Optional.ofNullable(T value);

empty()：该方法返回null值的Optional对象
of()：该方法返回指定非null值的Optional对象，如果传入的值为null，则会抛出NullPointerException异常。
ofNullable()：该方法返回一个Optional对象，它可能包含指定的值，也可能为null。

3.1、empty()

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

private final T value;

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

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

empty() 方法，将EMPTY赋值给一个新的 Optional 对象，EMPTY其实就是 new Optional<>(); 看私有构造方法 Optional()，其实就是把 value 设置成 null。

3.2、of()

//本方法
public static <T> Optional<T> of(T value) {
    return new Optional<>(value);
}

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

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

of() 方法，就是调用的私有构造方法 Optional(T value)，这个方法会调用 Objects.requireNonNull(value) ，这个方法会去判空，如果空就抛异常，非空就把对象返回。

3.3、ofNullable()

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

ofNullable() 方法，就是先判断 value 是否为空，如果是空的，就调用 empty() 方法，返回一个 value 为空的 Optional 对象，如果不为空，就调用 of() 方法返回一个 value 不为空的 Optional 对象。

四、常用方法

get()：该方法获取 Optional 对象中包含的值。如果 Optional 对象为空，则会抛出 NoSuchElementException 异常。
isPresent()：该方法检查 Optional 对象中是否包含非 null 的值，并返回 true 或 false。
ifPresent()：如果 Optional 对象中的值存在，则会执行该参数实例的 accept 方法，并传入 Optional 中包含的值，否则不做任何操作。
orElse()：该方法获取 Optional 对象中包含的值，如果该值为 null，则返回指定的默认值。
orElseGet()：该方法获取 Optional 对象中包含的值，如果该值为 null，则返回一个由 Supplier 接口提供的默认值。
orElseThrow()：该方法获取 Optional 对象中包含的值，如果该值为 null，则抛出指定的异常。
map()：接受一个函数作为参数，在 Optional 对象中的值存在时，将其转换为另一种类型，然后返回一个包含这个类型值的新 Optional 对象。如果 Optional 对象为空，则会直接返回一个空的 Optional 对象。
flatMap()：接受一个函数作为参数，但这里的函数返回值是一个 Optional 对象。如果 Optional 对象中的值存在，那么 flatMap() 方法会将其传递给函数作为参数，并且将函数的返回值包装在新的 Optional 对象中返回。如果 Optional 对象为空，那么直接返回一个空的 Optional 对象。
filter()：该方法对 Optional 对象中包含的值进行过滤，并返回一个 Optional 对象。如果 Optional 对象为空或者过滤器不匹配，则直接返回一个空的 Optional 对象。

4.1、get()

public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

get() 方法很简单，就是返回包装的实际值，如果值是空，就抛出NoSuchElementException异常

Optional optional1 = Optional.of("hello world");
Optional optional2 = Optional.empty();
System.out.println(optional1.get());
System.out.println(optional2.get());

打印结果：

hello world
java.util.NoSuchElementException: No value present

4.2、isPresent()

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

isPresent() 方法用于判断包装对象的值是否非空。

Optional optional1 = Optional.of("hello world");
Optional optional2 = Optional.of("");
Optional optional3 = Optional.empty();
System.out.println(optional1.isPresent());
System.out.println(optional2.isPresent());
System.out.println(optional3.isPresent());

打印结果：

true
true
false

4.3、ifPresent()

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

ifPresent() 方法用于如果的值存在，则会执行 consumer 的 accept 方法，并传入value，否则不做任何操作。

User user = new User();
String name = "zhangsan";
Optional.ofNullable(name).ifPresent(user::setName);
System.out.println(user);

打印结果：

User{name=‘zhangsan’}

4.4、orElse()

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

orElse() 方法用于如果获取value，如果 value 为空，返回传入的默认值。

Optional optional1 = Optional.of("hello world");
Optional optional2 = Optional.ofNullable(null);
System.out.println(optional1.orElse("hello java"));
System.out.println(optional2.orElse("hello java"));

打印结果：

hello world
hello java

4.5、orElseGet()

public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

orElseGet() 方法用于获取 value，如果 value 为空，返回一个由 Supplier 接口提供的默认值。

Optional<String> optional1 = Optional.of("hello world");
Optional<String> optional2 = Optional.ofNullable(null);
System.out.println(optional1.orElseGet(() -> "hello java"));
System.out.println(optional2.orElseGet(() -> "hello java"));

打印结果：

hello world
hello java

4.6、orElseThrow()

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

orElseThrow() 方法获取 value，如果 value 为空，则抛出指定的异常

Optional<String> optional1 = Optional.of("hello world");
Optional<String> optional2 = Optional.ofNullable(null);
System.out.println(optional1.orElseThrow(() -> new IllegalStateException("can't get value")));
System.out.println(optional2.orElseThrow(() -> new IllegalStateException("can't get value")));

打印结果：

hello world
java.lang.IllegalStateException: can’t get value

4.7、map()

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

map() 方法对 Optional 对象中包含的值进行转换，并返回一个新的 Optional 对象。如果 Optional 对象为空，则直接返回一个空的 Optional 对象。

User user = new User();
user.setName("zhangsan");
Optional<String> nameOptional = Optional.ofNullable(user).map(u -> u.getName());
System.out.println(nameOptional.orElse(null));

打印结果：

zhangsan

4.8、flatMap()

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

flatMap() 方法和 map() 方法类似，区别在于 flatMap() 方法的函数返回值是一个 Optional 对象，而 map() 方法的函数返回值是一个普通类型。

User user = new User();
user.setName("zhangsan");
Optional<String> nameOptional = Optional.ofNullable(user).flatMap(u -> Optional.ofNullable(user.getName()));
System.out.println(nameOptional.orElse(null));

打印结果：

zhangsan

4.9、filter()

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

filter() 方法通过传递一个Predicate（断言函数）来对Optional对象中的元素进行过滤。如果Optional对象中的值存在，filter方法会将其传递给断言函数进行判断。如果该元素符合断言函数的要求，则返回一个包含该元素的Optional对象。否则，返回空的Optional对象。

User user = new User();
user.setAge(20);
Optional.ofNullable(user).filter( u -> u.getAge() > 18).ifPresent(u ->  System.out.println("The user age is more than 18."));