玩转 Java8 Optional，让你代码更紧凑简洁且不再出现空指针

系列文章

序号	标题	文章链接
1	玩转 Java8 Stream，让你代码更高效紧凑简洁	https://blog.csdn.net/chenlixiao007/article/details/112752413
2	我使用 Lambda 表达式将上百行的代码精简到几行	https://blog.csdn.net/chenlixiao007/article/details/106366676

---

---

一、Optional 是什么？

官方定义：

public final class Optional<T> extends Object

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.

Additional methods that depend on the presence or absence of a contained value are provided, such as orElse() (return a default value if value not present) and ifPresent() (execute a block of code if the value is present).

This is a value-based class; use of identity-sensitivemin operations (including reference equality (==), identity hash code, or synchronization) on instances of Optional may have unpredictable results and should be avoided.

Optional 类，一个可包含或不包含非null值的容器对象。如果值存在，isPresent() 方法将返回 true 并且 get() 返回该值。

这个类还提供了其他方法，这些方法取决于它所包含值的存在与否，例如 orElse() （如果不存在值，则返回默认值）和 ifPresent()（如果存在值，则执行代码块）。

这是一个基于值的类，所以对于Optional实例的一些身份敏感操作（包括引用相等==，hashCode，同步）会产生无法预料的结果，应该避免使用。

二、Optional 有什么用？

1. 既然 Optional 类里面包含的值可以为 null ，不言而喻，那我们就可以不用显式地进行空值检测，即我们可以不用做判空操作，很好的解决了空指针异常问题（NullPointerException）。
2. Java8引入了函数式编程，而 Optional 是其中必不可少的一部分，帮助在范式中实现。结合 Stream 可以写出简洁高效的代码。

先举个栗子，输出一个员工的岗位名称，如果岗位名称为空，则输出默认值 - 实习生：

if (null != staff.getPost().getName()) {
    System.out.println(staff.getPost().getName());
} else {
    System.out.println("实习生");
}

以上语句有可能抛出NPE，为了健壮性，我们需要写判空：

if (null != staff) {
    Post post = staff.getPost();
    if (null != post) {
        String name = post.getName();
        if (null != name) {
            System.out.println(name);
        } else {
            System.out.println("实习生");
        }
    }
}

但是写了大量的判空操作，很繁琐，代码冗余还很难维护。如果使用Optional则很简单如下：

System.out.println(
        Optional.ofNullable(staff).map(Staff::getPost).map(Post::getName).orElse("实习生"));

三、Optional 源码详解

public final class Optional<T> {
    
    // 包含一个空值的Optional容器对象
    private static final Optional<?> EMPTY = new Optional<>();

    // Optional容器包含的值
    private final T value;

    // 私有构造方法，创建一个包含空值的Optional容器对象
    private Optional() {
        this.value = null;
    }

    // 静态方法，创建一个空值的Optional容器对象
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    // 私有构造方法，创建一个包含非空值的Optional容器对象
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    // 静态方法，创建一个包含非空值的Optional容器对象
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    // 静态方法，创建一个包含可空值的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;
    }

    // 如果值不为null，则使用改值调用consumer函数
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

    // 如果值存志，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

    // 如果值存在，则对其执行调用映射函数得到新的返回值。否则返回空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));
        }
    }

    // 如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的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));
        }
    }

    // 如果值存在，返回此值， 否则返回other。
    public T orElse(T other) {
        return value != null ? value : other;
    }

    // 如果值存在，返回此值， 否则调用other函数，并返回other函数的结果。
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

    // 如果值存在，返回此值，否则抛出由Supplier继承的异常
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }
}

四、Optional 类的使用

4.1 Optional 对象创建

// 创建一个空值的Optional对象
Optional<Object> emptyOptional = Optional.empty();
// 创建一个值可为空的Optional对象
Optional<Staff> staffOptional = Optional.ofNullable(staff);
// 创建一个非空值的Optional对象
Optional<Staff> staffOptional1 = Optional.of(staff);

4.2 get()

// 返回Optional容器对象中包含的值，如果值为null则抛出异常
Staff staff = staffOptional.get();

4.3 isPresent()

// 判断值是否存在
if (staffOptional.isPresent()) {
    Staff staff = staffOptional.get();
}

4.4 ifPresent(Consumer<? super T> consumer)

// 如果值存在，则输出值
staffOptional.ifPresent(System.out::println);

4.5 filter(Predicate<? super T> predicate)

// 是否存在18岁的员工，如果存在，则输出她的姓名
staffOptional.filter(staff -> staff.getAge() == 18)
                .ifPresent(staff -> System.out.println(staff.getName()));

4.6 map(Function<? super T, ? extends U> mapper)

// 获取员工的姓名，如果staff或name为null，输出'未知'
System.out.println(staffOptional.map(Staff::getName).orElse("未知"));

4.7 orElse(T other)

// 如果staff为null，将新生成的Staff对象赋值给staff
staff = Optional.ofNullable(staff).orElse(new Staff());

4.7 orElseGet(Supplier<? extends T> other)

// // 如果staff为null，才new出一个Staff对象，赋值给staff，它与orElse不同的是执行时机不同，orElseGet是值为空才调用other函数。
staff = Optional.ofNullable(staff).orElseGet(Staff::new);

4.8 orElseThrow(Supplier<? extends X> exceptionSupplier) throws X

// 如果staff为null，则抛出异常
staff = Optional.ofNullable(staff).orElseThrow(() -> new NullPointerException());

4.9 与 Stream 结合使用

// 找出一个员工大于等于18岁的员工
Optional<Staff> staffOptional = staffList.stream().filter(staff -> staff.getAge() >= 18).findFirst();
if (staffOptional.isPresent()) {
    Staff staff = staffOptional2.get();
}