java中的Optional

在 Java 8 中，Optional 是一个用于处理可能为 null 的值的容器类，旨在减少空指针异常（NullPointerException）并提升代码的可读性。以下是 Optional 的核心用法和最佳实践：

---

1. 创建 Optional 对象

1.1 常规创建方式

• Optional.of(T value)
  创建一个包含非空值的 Optional。如果传入 null，会抛出 NullPointerException。

  Optional<String> name = Optional.of("Alice");
  

• Optional.ofNullable(T value)
  允许传入 null，若值为 null，返回空的 Optional。

  Optional<String> nullableName = Optional.ofNullable(getName()); // 若 getName() 返回 null，nullableName 为空
  

• Optional.empty()
  创建一个空的 Optional。

  Optional<String> empty = Optional.empty();
  

---

2. 访问 Optional 中的值

2.1 检查值是否存在

• isPresent()
  判断 Optional 是否包含值。

  if (name.isPresent()) {
      System.out.println("值存在: " + name.get());
  }
  

• ifPresent(Consumer<? super T> consumer)
  如果值存在，执行传入的操作。

  name.ifPresent(n -> System.out.println("值存在: " + n));
  

• isEmpty()（Java 11+）
  判断 Optional 是否为空。

  if (empty.isEmpty()) {
      System.out.println("Optional 为空");
  }
  

2.2 安全获取值

• get()
  直接获取值，但需确保值存在（否则抛出 NoSuchElementException）。

  String result = name.get(); // 若 name 为空，抛出异常
  

• orElse(T other)
  若值存在返回该值，否则返回默认值。

  String defaultName = nullableName.orElse("Default Name");
  

• orElseGet(Supplier<? extends T> supplier)
  与 orElse() 类似，但默认值由 Supplier 延迟生成。

  String generatedName = nullableName.orElseGet(() -> "Generated Name");
  

• orElseThrow(Supplier<? extends X> exceptionSupplier)
  若值不存在，抛出指定异常。

  String actualName = nullableName.orElseThrow(() -> new IllegalArgumentException("值不存在"));
  

---

3. 转换与过滤 Optional 中的值

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

对 Optional 中的值进行转换，返回新的 Optional。

Optional<String> upperCaseName = name.map(String::toUpperCase);
upperCaseName.ifPresent(System.out::println); // 输出: ALICE

3.2 flatMap(Function<? super T, Optional<U>> mapper)

用于处理嵌套的 Optional，避免嵌套结构。

Optional<Optional<String>> nested = Optional.of(name);
Optional<String> flattened = nested.flatMap(o -> o); // 展平为 Optional<String>

3.3 filter(Predicate<? super T> predicate)

根据条件过滤值，若条件不满足，返回空的 Optional。

Optional<String> longName = name.filter(n -> n.length() > 5);
longName.ifPresent(System.out::println); // 若 name 为 "Alice"（长度 5），不输出

---

4. 链式操作示例

结合 map、filter 和 orElse 实现链式调用：

Optional<User> user = getUser();
String city = user
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("Unknown City");
System.out.println("城市: " + city);

---

5. Optional 的最佳实践

✅ 推荐做法

1. 方法返回值处理
   当方法可能返回 null 时，返回 Optional<T> 而不是 null。

   public Optional<User> findUserById(String id) {
       // ...
   }
   

2. 链式操作替代嵌套判断
   用 map 和 flatMap 替代多层 if-else。

   // 传统方式
   User user = getUser();
   if (user != null) {
       Address address = user.getAddress();
       if (address != null) {
           System.out.println(address.getCity());
       }
   }
   
   // 使用 Optional
   Optional.ofNullable(user)
       .map(User::getAddress)
       .map(Address::getCity)
       .ifPresent(System.out::println);
   

3. 提供默认值
   使用 orElse 或 orElseGet 处理缺失值。

   String name = Optional.ofNullable(user).map(User::getName).orElse("Guest");
   

⚠️ 常见误区

1. 不要用 Optional 声明类字段
   Optional 不适合用作类的字段，因为序列化和反序列化可能存在问题。

   // ❌ 不推荐
   private Optional<String> name;
   

2. 避免滥用 get()
   直接调用 get() 前必须检查值是否存在。

   // ❌ 错误
   String name = optional.get(); 
   
   // ✅ 正确
   String name = optional.orElseThrow(() -> new RuntimeException("值不存在"));
   

3. 不要过度使用 Optional
   仅在明确“值可能缺失”的场景使用，避免过度设计。

   // ❌ 不推荐
   public Optional<String> getName() { ... }
   
   // ✅ 推荐
   public String getName() { return Optional.ofNullable(...).orElse(""); }
   

---

6. Optional 与 Stream 的结合

Optional 可以与 Stream 结合使用，处理集合中的空值：

List<Optional<String>> optionalNames = ...;
List<String> names = optionalNames.stream()
    .filter(Optional::isPresent)
    .map(Optional::get)
    .collect(Collectors.toList());

---

7. 总结

方法	用途	示例
of	创建非空的 Optional	Optional.of("Hello")
ofNullable	创建允许为 null 的 Optional	Optional.ofNullable(getName())
isPresent	检查值是否存在	optional.isPresent()
ifPresent	若存在则执行操作	optional.ifPresent(System.out::println)
orElse	提供默认值	optional.orElse("Default")
map	转换值	optional.map(String::toUpperCase)
flatMap	展平嵌套的 Optional	optional.flatMap(o -> o)
filter	过滤值	optional.filter(s -> s.length() > 5)
orElseThrow	若无值则抛出异常	optional.orElseThrow(() -> new RuntimeException("无值"))

通过合理使用 Optional，可以显著减少空指针异常的风险，同时使代码更简洁、意图更明确。