Java 8 Optional类优雅处理空值的技巧 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

引言：为什么我们需要优雅处理空值？

在Java编程中，null 是一个非常常见的概念。它表示“无”或“不存在”，但在实际开发中，null 也常常成为代码中的“隐形杀手”。如果你不小心使用了 null，可能会导致 NullPointerException（简称 NPE），这是一种非常常见的运行时异常。NPE 不仅会让程序崩溃，还会让调试变得异常困难，因为它可能出现在任何地方，尤其是在大型项目中，追踪 null 的来源可能会耗费大量时间和精力。

为了解决这个问题，Java 8 引入了一个新的类——Optional，它提供了一种更加优雅的方式来处理可能为空的值。Optional 不仅仅是一个简单的容器，它还提供了一系列方法，帮助开发者避免 null 值带来的问题，同时使代码更加简洁、易读和健壮。

在这次讲座中，我们将深入探讨 Optional 类的使用技巧，帮助你在日常开发中更优雅地处理空值。我们会通过大量的代码示例和表格来解释 Optional 的各种用法，并引用一些国外的技术文档，确保你对这个类有全面的理解。准备好了吗？让我们开始吧！

什么是 `Optional`？

Optional<T> 是 Java 8 中引入的一个类，位于 java.util 包下。它的设计初衷是为了解决 null 值带来的问题，特别是 NullPointerException。Optional 是一个容器类，它可以包含一个非空的值，也可以不包含任何值（即空）。通过使用 Optional，我们可以显式地表达某个值可能存在也可能不存在的情况，而不是简单地返回 null。

`Optional` 的基本结构

Optional 类的定义如下：

public final class Optional<T> {
    private final T value;

    // 私有构造函数，防止外部直接创建实例
    private Optional(T value) {
        this.value = value;
    }

    // 静态工厂方法，用于创建包含值的 Optional 实例
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    // 静态工厂方法，用于创建空的 Optional 实例
    public static <T> Optional<T> empty() {
        return (Optional<T>) EMPTY;
    }

    // 静态工厂方法，允许传入 null 值，如果为 null 则返回空的 Optional
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    // 判断是否有值
    public boolean isPresent() {
        return value != null;
    }

    // 如果有值则返回该值，否则抛出 NoSuchElementException
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    // 如果有值则返回该值，否则返回指定的默认值
    public T orElse(T other) {
        return value != null ? value : other;
    }

    // 如果有值则返回该值，否则执行 Supplier 提供的逻辑并返回结果
    public T orElseGet(Supplier<? extends T> supplier) {
        return value != null ? value : supplier.get();
    }

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

    // 如果有值则对其应用给定的函数，否则返回空的 Optional
    public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        return value != null ? Optional.ofNullable(mapper.apply(value)) : empty();
    }

    // 如果有值则对其应用给定的函数，该函数返回 Optional，否则返回空的 Optional
    public <U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        return value != null ? mapper.apply(value) : empty();
    }

    // 如果有值则执行给定的 Consumer，否则不做任何操作
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null) {
            consumer.accept(value);
        }
    }

    // 如果有值则执行给定的 Consumer，否则执行其他操作
    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }
}

从上面的代码可以看出，Optional 提供了多种方法来处理可能为空的值。接下来，我们将详细介绍这些方法的具体用法和应用场景。

创建 `Optional` 实例

在使用 Optional 之前，我们首先需要创建一个 Optional 实例。Optional 提供了三种主要的静态工厂方法来创建实例：

Optional.of(T value)：用于创建包含非空值的 Optional 实例。如果传入的值为 null，则会抛出 NullPointerException。
```
Optional<String> optional = Optional.of("Hello, World!");
```
Optional.empty()：用于创建一个空的 Optional 实例，表示没有任何值。
```
Optional<String> optional = Optional.empty();
```
Optional.ofNullable(T value)：用于创建一个 Optional 实例，允许传入 null 值。如果传入的值为 null，则返回空的 Optional；否则返回包含该值的 Optional。
```
String name = null;
Optional<String> optional = Optional.ofNullable(name);  // 返回空的 Optional
```

选择合适的创建方式

of()：当你确定传入的值不会为 null 时，可以使用 of() 方法。这有助于在编译时捕获潜在的 null 值问题，因为 of(null) 会立即抛出异常。
empty()：当你明确知道某个值不存在时，可以直接使用 empty() 方法创建一个空的 Optional 实例。
ofNullable()：当你不确定传入的值是否为 null 时，应该使用 ofNullable()。它可以在运行时安全地处理 null 值，而不会抛出异常。

检查 `Optional` 是否包含值

在使用 Optional 时，我们通常需要检查它是否包含有效的值。Optional 提供了两种常用的方法来实现这一点：

isPresent()：返回一个布尔值，表示 Optional 是否包含非空值。如果包含值，则返回 true；否则返回 false。

Optional<String> optional = Optional.of("Hello, World!");
if (optional.isPresent()) {
   System.out.println("Optional contains a value: " + optional.get());
} else {
   System.out.println("Optional is empty");
}

ifPresent(Consumer<? super T> consumer)：如果 Optional 包含值，则执行给定的 Consumer 操作；否则不做任何操作。这个方法可以让代码更加简洁，避免显式的 if 判断。
```
Optional<String> optional = Optional.of("Hello, World!");
optional.ifPresent(System.out::println);
```
ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)：这是 Java 9 引入的一个新方法。它允许我们在 Optional 包含值时执行一个操作，而在 Optional 为空时执行另一个操作。这样可以避免使用 if-else 语句，使代码更加简洁。
```
Optional<String> optional = Optional.ofNullable(null);
optional.ifPresentOrElse(
   System.out::println,
   () -> System.out.println("Optional is empty")
);
```

示例：检查用户输入

假设我们有一个用户输入的字符串，可能为空。我们可以使用 Optional 来优雅地处理这种情况：

public void processUserInput(String userInput) {
    Optional<String> input = Optional.ofNullable(userInput);
    input.ifPresentOrElse(
        s -> System.out.println("User input: " + s),
        () -> System.out.println("No user input provided")
    );
}

获取 `Optional` 中的值

当 Optional 包含值时，我们可以通过以下几种方式获取该值：

get()：如果 Optional 包含值，则返回该值；否则抛出 NoSuchElementException。因此，get() 方法应该谨慎使用，最好在确认 Optional 包含值的情况下使用。
```
Optional<String> optional = Optional.of("Hello, World!");
String value = optional.get();  // 返回 "Hello, World!"
```
orElse(T other)：如果 Optional 包含值，则返回该值；否则返回指定的默认值。这个方法可以避免 null 值问题，并且不会抛出异常。
```
Optional<String> optional = Optional.ofNullable(null);
String value = optional.orElse("Default Value");  // 返回 "Default Value"
```
orElseGet(Supplier<? extends T> supplier)：与 orElse() 类似，但它允许我们通过 Supplier 提供一个懒加载的默认值。只有在 Optional 为空时，才会调用 Supplier 提供的逻辑。这在性能敏感的场景中非常有用，因为默认值的计算可能比较耗时。
```
Optional<String> optional = Optional.ofNullable(null);
String value = optional.orElseGet(() -> {
   System.out.println("Calculating default value...");
   return "Default Value";
});
```

orElseThrow(Supplier<? extends X> exceptionSupplier)：如果 Optional 包含值，则返回该值；否则抛出由 Supplier 提供的异常。这个方法可以用于自定义异常处理逻辑。

Optional<String> optional = Optional.ofNullable(null);
try {
   String value = optional.orElseThrow(() -> new IllegalArgumentException("Value cannot be null"));
} catch (IllegalArgumentException e) {
   System.out.println(e.getMessage());
}

示例：处理数据库查询结果

假设我们从数据库中查询一个用户信息，可能会返回 null。我们可以使用 Optional 来优雅地处理这种情况：

public User getUserById(Long id) {
    // 假设 userRepository.findById(id) 可能返回 null
    Optional<User> user = Optional.ofNullable(userRepository.findById(id));

    return user.orElseThrow(() -> new UserNotFoundException("User with ID " + id + " not found"));
}

转换 `Optional` 中的值

Optional 提供了两种方法来对其中的值进行转换：map() 和 flatMap()。这两种方法都可以用于对 Optional 中的值进行操作，但它们的行为有所不同。

map(Function<? super T, ? extends U> mapper)：如果 Optional 包含值，则对该值应用给定的函数，并返回一个新的 Optional，其中包含转换后的值；如果 Optional 为空，则返回空的 Optional。
```
Optional<String> optional = Optional.of("Hello, World!");
Optional<Integer> length = optional.map(String::length);
System.out.println(length.orElse(0));  // 输出 13
```

flatMap(Function<? super T, Optional<U>> mapper)：与 map() 类似，但它要求函数返回一个 Optional。flatMap() 会将内部的 Optional 解包，最终返回一个 Optional。如果 Optional 为空，则返回空的 Optional。

Optional<String> optional = Optional.of("Hello, World!");
Optional<Optional<Integer>> nestedOptional = optional.map(s -> Optional.of(s.length()));
Optional<Integer> flatMapped = optional.flatMap(s -> Optional.of(s.length()));

System.out.println(nestedOptional.orElse(Optional.empty()));  // 输出 Optional[13]
System.out.println(flatMapped.orElse(0));  // 输出 13

`map()` 与 `flatMap()` 的区别

map()：适用于将 Optional 中的值转换为另一种类型的值，但不会解包嵌套的 Optional。
flatMap()：适用于将 Optional 中的值转换为另一个 Optional，并且会自动解包嵌套的 Optional，最终返回一个扁平化的 Optional。

示例：处理嵌套的 `Optional`

假设我们有一个 Optional 包含一个 User 对象，而 User 对象中又包含一个 Optional 的 Address 对象。我们可以使用 flatMap() 来简化这种嵌套结构：

Optional<User> user = Optional.of(new User("Alice", Optional.of(new Address("123 Main St"))));

// 使用 flatMap 处理嵌套的 Optional
Optional<String> address = user.flatMap(u -> u.getAddress().map(Address::getStreet));
System.out.println(address.orElse("No address available"));  // 输出 "123 Main St"

`Optional` 的链式调用

Optional 的一大优势是可以进行链式调用，从而使代码更加简洁和易读。通过组合 map()、flatMap()、orElse() 等方法，我们可以编写出非常流畅的代码。

示例：链式调用处理用户信息

假设我们有一个 User 对象，其中包含 Optional 的 Address 和 PhoneNumber。我们可以使用链式调用来获取用户的完整信息：

class User {
    private String name;
    private Optional<Address> address;
    private Optional<PhoneNumber> phoneNumber;

    // 构造函数、getter 和 setter 省略
}

class Address {
    private String street;
    private String city;

    // 构造函数、getter 和 setter 省略
}

class PhoneNumber {
    private String number;

    // 构造函数、getter 和 setter 省略
}

public String getUserInfo(User user) {
    return user.getName() +
           ", Address: " + user.getAddress().map(Address::getStreet).orElse("No address") +
           ", City: " + user.getAddress().map(Address::getCity).orElse("No city") +
           ", Phone: " + user.getPhoneNumber().map(PhoneNumber::getNumber).orElse("No phone");
}

在这个例子中，我们使用了 map() 和 orElse() 方法来处理 Optional 中的值，并通过链式调用将所有信息拼接成一个字符串。这种方式不仅简洁，而且避免了 null 值带来的问题。

`Optional` 的局限性

尽管 Optional 在处理空值方面非常强大，但它也有一些局限性，开发者在使用时需要注意：

过度使用 Optional：虽然 Optional 可以帮助我们避免 null 值问题，但并不意味着我们应该在每个地方都使用它。过度使用 Optional 可能会使代码变得复杂，难以维护。因此，应该根据实际情况合理使用 Optional，而不是盲目地将其应用于所有可能为空的地方。
Optional 不能作为集合元素：Optional 本身是一个容器类，不能作为集合（如 List、Set）的元素。如果你需要存储多个可能为空的值，应该考虑使用其他数据结构，如 List<Optional<T>> 或 Stream<Optional<T>>。
Optional 不能作为字段类型：Optional 是一个不可变的容器类，因此不适合用作类的字段类型。如果你希望在类中表示某个字段可能为空，应该直接使用 null 或者其他方式来表示。
Optional 不能作为方法参数：虽然 Optional 可以作为返回值类型，但它不建议作为方法参数。传递 Optional 作为参数可能会导致代码难以理解，并且增加了不必要的复杂性。相反，应该在方法内部使用 Optional 来处理可能为空的值。

总结

Optional 是 Java 8 引入的一个非常有用的工具类，它可以帮助我们优雅地处理可能为空的值，避免 NullPointerException 的发生。通过使用 Optional，我们可以编写出更加简洁、易读和健壮的代码。

在这次讲座中，我们详细介绍了 Optional 的基本用法、创建方式、检查值的存在、获取值、转换值以及链式调用等技巧。我们还讨论了 Optional 的局限性，提醒大家在使用时要注意避免过度使用。

希望这次讲座能够帮助你在日常开发中更好地理解和使用 Optional，让你的代码更加优雅和可靠。如果你有任何问题或想法，欢迎随时提问！

引言：为什么我们需要优雅处理空值？

什么是 Optional？

Optional 的基本结构

创建 Optional 实例

选择合适的创建方式

检查 Optional 是否包含值

示例：检查用户输入

获取 Optional 中的值

示例：处理数据库查询结果

转换 Optional 中的值

map() 与 flatMap() 的区别

示例：处理嵌套的 Optional

Optional 的链式调用