Java 8 到 Java 21 系列之 Optional 类型：优雅地处理空值（Java 8）

系列目录

• Java8 到 Java21 系列之 Lambda 表达式：函数式编程的开端（Java 8）
• Java 8 到 Java 21 系列之 Stream API：数据处理的新方式（Java 8）
• Java 8 到 Java 21 系列之 Optional 类型：优雅地处理空值（Java 8）
• Java 8 到 Java 21 系列之 新日期时间 API：精确的时间管理（Java 8） 更新中
• Java 8 到 Java 21 系列之 模块化系统：构建模块化的 Java 应用（Java 9） 更新中
• Java 8 到 Java 21 系列之 JShell：即时运行 Java 代码（Java 9） 更新中
• Java 8 到 Java 21 系列之 局部变量类型推断：var 关键字的妙用（Java 10） 更新中
• Java 8 到 Java 21 系列之 HTTP Client API：现代网络通信的基础（Java 11） 更新中
• Java 8 到 Java 21 系列之 ZGC：低延迟垃圾收集器的秘密（Java 11） 更新中
• Java 8 到 Java 21 系列之 Switch 表达式的进化（Java 12） 更新中
• Java 8 到 Java 21 系列之 文本块：轻松管理多行字符串（Java 13） 更新中
• Java 8 到 Java 21 系列之 instanceof 模式匹配：简化类型检查（Java 14） 更新中
• Java 8 到 Java 21 系列之 Records：数据类的全新体验（Java 14） 更新中
• Java 8 到 Java 21 系列之 密封类：限制继承的艺术（Java 15） 更新中
• Java 8 到 Java 21 系列之 外部函数与内存 API：无缝集成本地代码（Java 17） 更新中
• Java 8 到 Java 21 系列之 Sealed Classes 正式登场：增强类型安全性（Java 17） 更新中
• Java 8 到 Java 21 系列之 强封装 JDK 内部 API：保护你的应用程序（Java 17） 更新中
• Java 8 到 Java 21 系列之 增强的伪随机数生成器：更高质量的随机数（Java 17） 更新中
• Java 8 到 Java 21 系列之 虚拟线程：并发编程的新纪元（Java 21） 更新中
• Java 8 到 Java 21 系列之 分代 ZGC 优化：迈向更高性能（Java 21） 更新中
• Java 8 到 Java 21 系列之 序列集合 API：简化集合操作（Java 21） 更新中

---

摘要与引言

在软件开发的实践中，空指针异常（NullPointerException）是开发者常常遇到的问题之一。这类异常往往会导致程序崩溃，尤其是在大型系统中定位问题所在会变得非常棘手。为了帮助开发者更优雅地处理可能为空的值，Java 8 引入了 Optional 类型，这一特性极大地改善了代码的健壮性和可读性。

---

1 什么是 Optional

Optional<T> 是一个容器类，它可以包含一个非空值或者不包含任何值（即空值）。它的主要目的是提供一种更加安全和清晰的方式来处理可能为空的值，从而减少空指针异常的风险。

1.1 空指针异常演示

下面的例子展示了未使用 Optional 时可能出现的空指针异常。

/**
 * Optional单元测试案例
 *
 * @author JunLiang
 */
@DisplayName("Optional单元测试案例")
public class OptionalTest {
    
    @DisplayName("空指针测试")
    @Test
    public void nullPointerTest() {
        UserService userService = new UserService();
        User user = userService.getUserById(1L);
        System.out.println(user.getName()); // 可能抛出NullPointerException
    }

    class User {
        private String name;

        public User(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    class UserService {
        public User getUserById(Long id) {
            // 假设这里查询数据库，如果找不到用户则返回null
            return null;
        }
    }

}

直接运行单元测试示例报空指针异常

1.2 使用 Optional 处理

现在我们将上面的示例修改为使用 Optional 来避免空指针异常。
当查询对应的用户为空时，给用户名默认值guest

/**
 * Optional单元测试案例
 *
 * @author JunLiang
 */
@DisplayName("Optional单元测试案例")
public class OptionalTest {

    @DisplayName("空指针测试 - 使用Optional改进")
    @Test
    public void nullPointerTestWithOptional() {
        UserService userService = new UserService();

        // 如果用户为空，则提供默认值 "Guest"
        Optional<User> optionalUser = Optional.ofNullable(userService.getUserById(1L));
        String userName = optionalUser.map(User::getName).orElse("Guest");

        // 打印用户名或默认值
        System.out.println("默认用户名: " + userName);
    }

   class User {
        private String name;

        public User(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    class UserService {
        public User getUserById(Long id) {
            // 假设这里查询数据库，如果找不到用户则返回null
            return null; // 为了演示，总是返回null
        }
    }
}

执行结果

当查询对应的用户为空时，给用配合try捕获异常进行报错提示

/**
 * Optional单元测试案例
 *
 * @author JunLiang
 */
@DisplayName("Optional单元测试案例")
public class OptionalTest {

    @DisplayName("空指针测试 - 使用Optional改进")
    @Test
    public void nullPointerTestWithOptional() {
        UserService userService = new UserService();

        // 如果用户为空，则抛出自定义异常
        try {
            // 使用Optional包装可能为空的返回值
            Optional<User> optionalUser = Optional.ofNullable(userService.getUserById(1L));

            // 尝试获取用户名，如果用户为空则抛出自定义异常
            String userName = optionalUser.map(User::getName)
                .orElseThrow(() -> new RuntimeException("用户不存在"));

            // 打印用户名
            System.out.println("用户名: " + userName);
        } catch (RuntimeException e) {
            // 捕获运行时异常并打印日志
            System.out.println("捕获到运行时异常: " + e.getMessage());
        }
        
    }

    class User {
        private String name;

        public User(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    class UserService {
        public User getUserById(Long id) {
            // 假设这里查询数据库，如果找不到用户则返回null
            return null; // 为了演示，总是返回null
        }
    }
}

执行结果

通过上述介绍可以看出，Optional 提供了一种优雅的方式处理潜在的空值。在实际项目中，我们可以在方法返回值、数据传输对象（DTO）、以及链式调用等场景下充分利用 Optional 来提高代码质量。

例如，在服务层方法返回用户信息时，可以返回 Optional<User> 而不是直接返回 User，这样可以明确表达返回值可能是空的意图，并且鼓励调用方考虑如何处理这种情况。

---

2 常见Optional使用场景

2.1 创建 Optional 对象

• 有值的情况：当你确定某个变量不是 null 时，可以使用 Optional.of()。

  Optional<String> nonNullOptional = Optional.of("Hello");
  

• 可能为空的情况：当你不确定某个变量是否为 null 时，应该使用 Optional.ofNullable()。

  String nullableValue = null;
  Optional<String> nullableOptional = Optional.ofNullable(nullableValue);
  

• 无值的情况：当需要表示没有值时，可以使用 Optional.empty()。

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

2.2 检查是否存在值

• 使用 isPresent() 或者 Java 11 引入的 isEmpty() 方法来检查 Optional 是否包含值。

  if (nonNullOptional.isPresent()) {
      System.out.println("Value is present: " + nonNullOptional.get());
  }
  

2.3 执行动作如果存在值

• 使用 ifPresent() 方法在 Optional 包含值时执行一个操作。

  nonNullOptional.ifPresent(value -> System.out.println("Value is present: " + value));
  

2.4 获取值或默认值

• 使用 orElse() 提供一个默认值，在 Optional 为空时返回该默认值。

  String result = nullableOptional.orElse("Default Value");
  

• 使用 orElseGet() 提供一个 Supplier 来延迟计算默认值。

  String computedResult = nullableOptional.orElseGet(() -> computeDefaultValue());
  

2.5. 抛出异常

• 使用 orElseThrow() 在 Optional 为空时抛出异常。

  String value = nullableOptional.orElseThrow(() -> new IllegalArgumentException("Value not present"));
  

2.6 转换值

• 使用 map() 方法对 Optional 中的值应用一个函数。

  Optional<Integer> lengthOptional = nonNullOptional.map(String::length);
  

• 使用 flatMap() 方法避免嵌套的 Optional 结构。

  Optional<Optional<String>> nestedOptional = Optional.of("World").map(s -> Optional.of(s));
  Optional<String> flatMapped = nestedOptional.flatMap(x -> x); // Unwraps the nested Optional
  

2.7 过滤值

• 使用 filter() 方法根据给定条件筛选值。

  Optional<String> filteredOptional = nonNullOptional.filter(s -> s.startsWith("He"));
  

2.8. 链式调用

• 可以组合多个操作形成链式调用来简化代码。

  Optional<String> result = Optional.of("hello")
          .filter(s -> s.length() > 3)
          .map(String::toUpperCase)
          .orElse("DEFAULT");
  

这些只是 Optional 类的一些基本用法。通过合理使用这些方法，可以使代码更加简洁、安全，并且更易于理解。

---

总结

Optional 是 Java 8 引入的一个重要特性，它提供了一种新的方式来处理可能为空的值，减少了空指针异常的发生，同时提升了代码的可读性和维护性。通过使用 Optional，开发者可以明确地表达出某段代码或某个方法返回值可能是空的意图，并鼓励调用者考虑如何优雅地处理这些情况。

在实际应用中，合理利用 Optional 的各种方法（如 isPresent()、ifPresent()、map()、flatMap()、filter() 等），可以让我们编写出更加健壮且易于理解的代码。尤其是当涉及到链式调用或者复杂的数据处理流程时，Optional 能够有效地简化逻辑，减少不必要的嵌套和条件判断，使得代码更加简洁明了。

然而，值得注意的是，虽然 Optional 提供了诸多便利，但它并不适合所有场景。过度使用 Optional 可能会导致代码变得冗长，特别是在基本数据类型上使用 Optional 时需要特别小心，因为这可能会带来性能上的损耗。因此，在使用 Optional 时应当根据具体情况权衡利弊，确保其带来的好处超过可能的缺点。总之，Optional 是一个强大的工具，正确地使用它可以显著提高程序的健壮性和开发效率。