Optional优雅处理空值问题

Optional 是 Java 8 引入的容器类，用于表示可能为空的值。本文讲解其正确用法和常见误区。

为什么需要 Optional

传统空值处理的问题：

// 多层嵌套判空
String city = user.getAddress().getCity();  // 可能NPE

// 防御式编程导致代码臃肿
String city = null;
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        city = address.getCity();
    }
}

Optional 基本用法

创建 Optional

// 非空值
Optional<String> opt1 = Optional.of("hello");  // null会抛NPE

// 可能为null的值
Optional<String> opt2 = Optional.ofNullable(getString());

// 空Optional
Optional<String> opt3 = Optional.empty();

获取值

Optional<String> opt = Optional.of("hello");

// 直接获取（为空时抛NoSuchElementException）
String val1 = opt.get();

// 提供默认值
String val2 = opt.orElse("default");

// 延迟计算默认值
String val3 = opt.orElseGet(() -> expensiveOperation());

// 为空时抛出异常
String val4 = opt.orElseThrow(() -> new NotFoundException());

条件操作

Optional<String> opt = Optional.of("hello");

// 值存在时执行
opt.ifPresent(System.out::println);

// 值存在时转换，否则返回空
Optional<String> upper = opt.map(String::toUpperCase);

// 值存在时返回新的Optional
Optional<String> result = opt.flatMap(this::findByName);

// 过滤
Optional<String> filtered = opt.filter(s -> s.length() > 3);

实战场景

1. 链式调用避免嵌套

// 传统写法
String city = null;
if (user != null && user.getAddress() != null) {
    city = user.getAddress().getCity();
}

// Optional 写法
String city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("Unknown");

2. 方法返回值

// 好的设计：返回Optional表示可能为空
public Optional<User> findById(Long id) {
    User user = userDao.findById(id);
    return Optional.ofNullable(user);
}

// 调用方明确处理空值
User user = findById(1L)
    .orElseThrow(() -> new UserNotFoundException(1L));

3. 异常转换

Optional.ofNullable(user)
    .filter(u -> u.getStatus() == Status.ACTIVE)
    .orElseThrow(() -> new IllegalStateException("用户未激活"));

常见误区

1. Optional 作为字段

// 错误！Optional不是为字段设计的
public class User {
    private Optional<String> nickname;  // 不要这样做
}

// 正确：字段直接用null表示空
public class User {
    private String nickname;
    
    public Optional<String> getNickname() {
        return Optional.ofNullable(nickname);
    }
}

2. Optional 作为方法参数

// 错误！参数类型不应是Optional
public void process(Optional<String> name) { ... }

// 正确：重载方法
public void process(String name) {
    process(name, false);
}

public void process(String name, boolean uppercase) { ... }

3. isPresent + get 的组合

// 错误！回到了if-null的模式
if (opt.isPresent()) {
    String val = opt.get();
    // ...
}

// 正确：使用ifPresent
opt.ifPresent(val -> {
    // ...
});

// 或map/filter
opt.map(...).filter(...).orElse(...);

4. 默认值为null

// 错误！失去了Optional的意义
String val = opt.orElse(null);

// 正确：提供有意义的默认值
String val = opt.orElse("");

Optional 与 Stream 结合

List<Optional<String>> optionals = Arrays.asList(
    Optional.of("a"),
    Optional.empty(),
    Optional.of("b")
);

// 过滤空值并收集
List<String> results = optionals.stream()
    .flatMap(Optional::stream)  // Java 9+
    .collect(Collectors.toList());
// 结果: ["a", "b"]

// Java 8 写法
List<String> results = optionals.stream()
    .filter(Optional::isPresent)
    .map(Optional::get)
    .collect(Collectors.toList());

性能考量

Optional 是对象，有创建开销：

// 简单场景直接返回null更好
public String findName() {
    return condition ? "name" : null;  // 比Optional更高效
}

// 复杂链式操作使用Optional
public String findCity() {
    return Optional.ofNullable(user)
        .map(User::getAddress)
        .map(Address::getCity)
        .orElse("Unknown");
}

最佳实践

作为返回值：明确表示方法可能不返回结果
不用于字段：字段用null，通过getter返回Optional
不用于参数：使用重载或Builder模式
避免isPresent + get：使用函数式操作
不提供null默认值：默认值应是有意义的值

// 优秀的API设计
public class UserService {
    // 可能找不到用户，返回Optional
    public Optional<User> findById(Long id) { ... }
    
    // 用户必须存在，找不到抛异常
    public User getById(Long id) { ... }
}