java optional 怎么用

在Java开发中,空指针异常（NullPointerException）一直是困扰开发者的问题，为了优雅地处理可能为null的值，Java 8引入了Optional类，它是一个容器对象，可以包含或不包含非null值，通过提供一系列方法，让开发者能够以函数式编程的方式避免显式的null检查，从而写出更简洁、更健壮的代码，本文将详细介绍Optional的正确使用方式，帮助开发者掌握这一实用工具。

Optional的创建：明确值的“存在性”

Optional的核心是表示“可能存在或不存在”的值，因此创建方式需要根据值的实际来源选择，Java提供了三种主要的创建方法：

1. Optional.empty()：创建一个不包含任何值的空Optional实例。

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

   这种方式明确表示当前场景下值可能不存在,适用于逻辑上允许为空的情况。

2. Optional.of(T value)：创建一个包含非null值的Optional实例，如果传入的value为null，会立即抛出NullPointerException。

   String name = "Alice";
   Optional<String> nameOpt = Optional.of(name); // 正常
   Optional<String> nullOpt = Optional.of(null); // 抛出NullPointerException

   适用于确定值不为null的场景,作为参数校验的“断言”，提前暴露问题。

3. Optional.ofNullable(T value)：这是最常用的创建方式，它接受任意值（包括null）：如果value为null，返回empty()；否则返回包含value的Optional。

   String nullableName = null;
   Optional<String> safeOpt = Optional.ofNullable(nullableName); // 返回Optional.empty()

   适用于无法确定值是否为null的场景,避免手动null检查。

核心操作：安全地获取值

Optional的价值在于提供了一套安全获取值的方法,避免直接调用get()导致的异常，以下是常用的获取方法：

1. orElse(T other)：如果Optional包含值，返回该值；否则返回other（默认值）。

   Optional<String> opt = Optional.empty();
   String result = opt.orElse("default"); // 返回"default"

   适用于需要提供明确默认值的场景,简单直接。

2. orElseGet(Supplier<? extends T> supplier)：与orElse类似，但other是通过Supplier函数式接口提供的，区别在于：只有当Optional为空时，supplier才会被调用，避免了不必要的计算或对象创建。

   

   Optional<String> opt = Optional.empty();
   String result = opt.orElseGet(() -> getDefaultName()); // 只有opt为空时才调用getDefaultName()

   适用于默认值需要“延迟计算”的场景，性能更优。

3. orElseThrow(Supplier<? extends X> exceptionSupplier)：如果Optional包含值，返回该值；否则抛出由exceptionSupplier提供的异常。

   Optional<String> opt = Optional.empty();
   String result = opt.orElseThrow(() -> new IllegalArgumentException("值不能为空")); // 抛出IllegalArgumentException

   适用于“值必须存在”的场景，比get()更明确，能自定义异常信息，便于调试。

4. get()：直接获取Optional中的值。注意：如果Optional为空，会抛出NoSuchElementException，除非能确保Optional一定包含值（如通过of()创建），否则应避免使用get()。

过滤与映射：灵活处理值

Optional提供了filter()和map()方法，支持对值进行条件判断和转换，保持代码的函数式风格。

1. filter(Predicate<? super T> predicate)：如果Optional包含值，且该值满足predicate条件，返回包含该值的Optional；否则返回empty()。

   Optional<Integer> opt = Optional.of(10);
   Optional<Integer> filteredOpt = opt.filter(x -> x > 5); // 返回Optional.of(10)
   Optional<Integer> emptyOpt = opt.filter(x -> x > 15); // 返回Optional.empty()

   适用于“值需满足特定条件”的场景，避免后续处理无效值。

2. map(Function<? super T, ? extends U> mapper)：如果Optional包含值，对值应用mapper函数，并将结果包装成Optional返回；如果为空，返回empty()。

   Optional<String> opt = Optional.of("123");
   Optional<Integer> lengthOpt = opt.map(String::length); // 返回Optional.of(3)

   适用于需要从值中提取或转换的场景,避免null检查。

3. flatMap(Function<? super T, Optional> mapper)：与map类似，但mapper函数返回的必须是Optional（而不是普通值）。它会“拆包”外层的Optional，避免嵌套。

   class User { Optional<Address> getAddress(); }
   class Address { String getCity(); }
   Optional<User> userOpt = Optional.of(new User());
   Optional<String> cityOpt = userOpt.flatMap(User::getAddress)
                                  .flatMap(address -> Optional.of(address.getCity()));

   适用于处理嵌套Optional的场景（如从对象中获取可能为空的属性），避免出现Optional<Optional>的嵌套结构。

   

// 传统方式：多层null检查
String city = null;
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        city = address.getCity();
    }
}
// Optional链式调用
Optional<String> cityOpt = Optional.ofNullable(user)
                                  .map(User::getAddress)
                                  .map(Address::getCity)
                                  .orElse("未知城市");