在 Java 8 中，引入了一个非常重要的特性——Optional 类。Optional 是一个容器对象，用于表示可能为 null 的值。它是一个专门用于避免 NullPointerException 的工具类，目的是提供一种更加优雅和安全的处理 null 的方式。通过 Optional，可以显式地表达一个值可能不存在（即为空）。

Optional 的定义

Optional 是一个容器对象，它可以包含或不包含一个非空值。使用 Optional 可以避免代码中直接使用 null，从而减少 NullPointerException 的发生。

复制
1public class Optional<T> {
2    private final T value;
3    
4    private Optional(T value) {
5        this.value = value;
6    }
7
8    public static <T> Optional<T> of(T value) {
9        return new Optional<>(value);
10    }
11
12    public static <T> Optional<T> empty() {
13        return new Optional<>(null);
14    }
15
16    public T get() {
17        if (value == null) {
18            throw new NoSuchElementException("No value present");
19        }
20        return value;
21    }
22
23    public boolean isPresent() {
24        return value != null;
25    }
26
27    public void ifPresent(Consumer<? super T> consumer) {
28        if (value != null) {
29            consumer.accept(value);
30        }
31    }
32
33    public T orElse(T other) {
34        return (value != null) ? value : other;
35    }
36}

常见的 Optional 方法

1. Optional.of(T value)：返回一个包含非 null 值的 Optional。如果传入 null，会抛出 NullPointerException。

   复制
   1Optional<String> optional = Optional.of("Hello");

2. Optional.ofNullable(T value)：返回一个可能为空的 Optional。如果值为 null，返回 Optional.empty()，否则返回包含该值的 Optional。

   复制
   1Optional<String> optional = Optional.ofNullable(someValue);

3. Optional.empty()：返回一个空的 Optional。

   复制
   1Optional<String> optional = Optional.empty();

4. T get()：如果 Optional 包含值，返回该值。如果 Optional 是空的，会抛出 NoSuchElementException。

   复制
   1String value = optional.get();

5. boolean isPresent()：检查 Optional 中是否包含值。

   复制
   1boolean isPresent = optional.isPresent();

6. void ifPresent(Consumer<? super T> consumer)：如果 Optional 中的值存在，执行传入的 consumer 操作。

   复制
   1optional.ifPresent(value -> System.out.println(value));

7. T orElse(T other)：如果 Optional 中有值，返回该值，否则返回提供的替代值。

   复制
   1String value = optional.orElse("Default Value");

8. T orElseGet(Supplier<? extends T> other)：如果 Optional 中有值，返回该值，否则通过 Supplier 提供一个替代值。

   复制
   1String value = optional.orElseGet(() -> "Default Value");

9. Optional<T> filter(Predicate<? super T> predicate)：如果 Optional 中的值存在且符合给定的条件，则返回该值，否则返回一个空的 Optional。

   复制
   1Optional<String> result = optional.filter(value -> value.length() > 3);

10. Optional<T> map(Function<? super T, ? extends U> mapper)：如果 Optional 中的值存在，则应用给定的 mapper 函数，返回新的 Optional，否则返回空的 Optional。

    复制
    1Optional<String> result = optional.map(String::toUpperCase);

11. Optional<T> flatMap(Function<? super T, Optional<U>> mapper)：和 map() 类似，但 mapper 返回的是一个 Optional，因此 flatMap 的返回结果是一个 Optional。

    复制
    1Optional<String> result = optional.flatMap(value -> Optional.of(value.toUpperCase()));

Optional 的优势

1. 避免 NullPointerException：传统的 null 检查非常容易出错，而 Optional 明确表达了“值可能为空”的含义，避免了空指针异常。

2. 代码更简洁：通过 Optional 的方法链（例如 map(), filter(), ifPresent() 等），可以更简洁、优雅地处理 null 值。

3. 明确地表达“值缺失”的状态：Optional 可以作为一个明确的设计决策，表示一个方法可能不会返回有效的值。这比简单地返回 null 更加直观。

4. 支持函数式编程：Optional 可以与 Java 8 引入的其他函数式编程特性（如 Stream）结合使用，使得代码更加声明式和函数式。

使用 Optional 的场景

Optional 适用于以下场景：

• 方法返回值可能为空（例如查找操作，查询数据库等）。
• 需要明确地表达“没有值”的含义，并希望避免 null。
• 想使用函数式编程风格来避免 null 值带来的问题。

注意事项

1. 避免滥用 Optional：Optional 主要用于返回值为空的场景，不应作为参数类型来使用。过多地使用 Optional 会导致代码变得冗长且难以理解。

2. Optional 不适用于性能敏感的场景：虽然 Optional 提供了更好的代码风格和可读性，但它会增加一定的性能开销。因此，在性能关键的代码路径中应该谨慎使用。