一、基础概念

1. 设计初衷

Optional 类的主要目的是解决 Java 中臭名昭著的 NullPointerException (NPE) 问题。它是一个容器对象，可以包含也可以不包含非空值。

2. 核心作用

• 明确表示"无值"的情况，替代 null 引用
• 强制调用方处理值可能不存在的情况
• 提供函数式风格的链式操作

3. 适用场景

• 方法返回值可能为 null 时
• 需要明确表达"无结果"语义时
• 链式处理可能为 null 的值时

// 传统方式 - 容易产生NPE
public String getManagerName(Employee employee) {
    return employee.getDepartment().getManager().getName();
}

// Optional方式 - 更安全
public Optional<String> getManagerName(Employee employee) {
    return Optional.ofNullable(employee)
                  .flatMap(Employee::getDepartment)
                  .flatMap(Department::getManager)
                  .map(Manager::getName);
}

二、基础使用

1. 创建 Optional 对象

// 创建示例
Optional<String> nonEmpty = Optional.of("Hello"); // 包含值
Optional<String> nullable = Optional.ofNullable(null); // 空Optional
Optional<String> empty = Optional.empty(); // 空Optional

2. 获取值的方法

Optional<String> opt = Optional.ofNullable(getRandomString()); // 可能返回null

// 不安全的方式
String value = opt.get(); // 可能抛出NoSuchElementException

// 安全的方式
String value1 = opt.orElse("default"); // 为空时返回"default"
String value2 = opt.orElseGet(() -> generateDefault()); // 延迟生成默认值
String value3 = opt.orElseThrow(() -> new IllegalStateException("Value absent")); // 自定义异常

三、链式调用

1. map() 与 flatMap()

• map(): 如果值存在，应用函数并包装结果到 Optional
• flatMap(): 如果值存在，应用返回 Optional 的函数并"展平"结果

class User {
    private String name;
    private Address address;
    // getters
}

class Address {
    private String street;
    // getter
}

// 传统多层嵌套检查
String street = null;
if (user != null && user.getAddress() != null) {
    street = user.getAddress().getStreet();
}

// Optional + map
Optional<String> streetOpt = Optional.ofNullable(user)
                                   .map(User::getAddress)
                                   .map(Address::getStreet);

// Optional + flatMap (当getAddress返回Optional时)
Optional<String> streetOpt = Optional.ofNullable(user)
                                   .flatMap(User::getAddress)
                                   .map(Address::getStreet);

2. 业务逻辑示例

// 计算订单总价，考虑折扣
public BigDecimal calculateTotal(Order order) {
    return Optional.ofNullable(order)
                  .map(Order::getItems)
                  .map(this::calculateSubtotal)
                  .map(subtotal -> applyDiscount(subtotal, order.getDiscount()))
                  .orElse(BigDecimal.ZERO);
}

private BigDecimal calculateSubtotal(List<Item> items) {
    return items.stream()
               .map(item -> item.getPrice().multiply(item.getQuantity()))
               .reduce(BigDecimal.ZERO, BigDecimal::add);
}

private BigDecimal applyDiscount(BigDecimal subtotal, Discount discount) {
    return Optional.ofNullable(discount)
                  .map(d -> subtotal.multiply(BigDecimal.ONE.subtract(d.getPercentage())))
                  .orElse(subtotal);
}

四、高级特性

1. filter() 方法

// 只有当值存在且满足条件时才保留
Optional<String> longName = name.filter(n -> n.length() > 5);

// 实际应用：验证用户输入
public Optional<User> validateUser(User user) {
    return Optional.ofNullable(user)
                  .filter(u -> u.getName() != null && !u.getName().isEmpty())
                  .filter(u -> u.getAge() >= 18);
}

2. stream() 方法

// 将Optional转为Stream
List<String> names = Arrays.asList("Alice", null, "Bob", null, "Charlie");
List<String> nonNullNames = names.stream()
                                .map(Optional::ofNullable)
                                .flatMap(Optional::stream)
                                .collect(Collectors.toList());
// 结果: [Alice, Bob, Charlie]

五、性能与陷阱

1. orElse() vs orElseGet()

// orElse() - 总是会执行，即使值存在
String value = optional.orElse(expensiveOperation());

// orElseGet() - 只有值不存在时才会执行
String value = optional.orElseGet(() -> expensiveOperation());

// 性能对比
Optional<String> opt = Optional.of("value");

long start = System.nanoTime();
String v1 = opt.orElse(expensiveOperation());
long duration1 = System.nanoTime() - start;

start = System.nanoTime();
String v2 = opt.orElseGet(() -> expensiveOperation());
long duration2 = System.nanoTime() - start;

// duration1 会包含 expensiveOperation() 的执行时间
// duration2 不会执行 expensiveOperation()

2. get() 的安全隐患

Optional<String> optional = getOptionalValue();

// 不安全的用法 - 可能抛出NoSuchElementException
String value = optional.get();

// 安全替代方案
if (optional.isPresent()) {
    String value = optional.get();
    // 处理value
}

// 或者更函数式的写法
optional.ifPresent(value -> {
    // 处理value
});

六、源码分析

1. 核心字段

public final class Optional<T> {
    private final T value; // 存储的实际值
    
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    
    // 其他方法...
}

2. map() 方法实现

public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent()) {
        return empty();
    } else {
        return Optional.ofNullable(mapper.apply(value));
    }
}

3. flatMap() 方法实现

public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent()) {
        return empty();
    } else {
        @SuppressWarnings("unchecked")
        Optional<U> r = (Optional<U>) mapper.apply(value);
        return Objects.requireNonNull(r);
    }
}

七、自定义扩展

1. 安全API设计示例

public class OptionalUtils {
    
    // 安全转换类型
    public static <T, U> Optional<U> safeCast(T obj, Class<U> targetClass) {
        return Optional.ofNullable(obj)
                      .filter(targetClass::isInstance)
                      .map(targetClass::cast);
    }
    
    // 集合非空检查
    public static <T> Optional<List<T>> nonEmptyList(List<T> list) {
        return Optional.ofNullable(list)
                      .filter(l -> !l.isEmpty());
    }
    
    // 链式检查多个Optional
    @SafeVarargs
    public static <T> Optional<List<T>> allPresent(Optional<T>... optionals) {
        return Arrays.stream(optionals)
                    .map(opt -> opt.orElse(null))
                    .anyMatch(Objects::isNull) 
                    ? Optional.empty()
                    : Optional.of(Arrays.stream(optionals)
                               .map(Optional::get)
                               .collect(Collectors.toList()));
    }
}

// 使用示例
Optional<List<String>> validNames = OptionalUtils.nonEmptyList(names);
Optional<Integer> number = OptionalUtils.safeCast(obj, Integer.class);

常见误区

过度使用 Optional

反例:

// 不必要的Optional包装
public Optional<Optional<Optional<String>>> getDeepValue() {
    // ...
}

// Optional作为字段 - 不推荐
class User {
    private Optional<String> name; // 反模式
}

// Optional作为参数 - 使API复杂化
public void process(Optional<String> input) {
    // ...
}

最佳实践:

• Optional 主要用于方法返回值
• 避免多层嵌套 Optional
• 不要用 Optional 作为类字段或方法参数
• 在集合中直接使用空集合而非 Optional

对比分析

与传统判空对比

与 Guava Optional 对比

场景化实战

DAO层查询

public interface UserRepository {
    Optional<User> findById(Long id);
}

// 服务层使用
public UserProfile getUserProfile(Long userId) {
    return userRepository.findById(userId)
                       .map(this::convertToProfile)
                       .orElseThrow(() -> new UserNotFoundException(userId));
}

private UserProfile convertToProfile(User user) {
    // 转换逻辑
}

服务层数据处理

public Optional<Order> applyDiscount(Order order, String discountCode) {
    return Optional.ofNullable(order)
                  .filter(o -> o.getStatus() == OrderStatus.ACTIVE)
                  .flatMap(o -> discountService.findDiscount(discountCode)
                  .map(discount -> {
                      o.applyDiscount(discount);
                      return o;
                  });
}

Controller层响应

@GetMapping("/users/{id}")
public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
    return userService.findById(id)
                    .map(user -> ResponseEntity.ok(toDto(user)))
                    .orElse(ResponseEntity.notFound().build());
}

复杂场景

处理集合中的 Optional

List<Optional<String>> optionalList = Arrays.asList(
    Optional.of("A"),
    Optional.empty(),
    Optional.of("B")
);

// 方法1: filter + map
List<String> result = optionalList.stream()
                                .filter(Optional::isPresent)
                                .map(Optional::get)
                                .collect(Collectors.toList());

// 方法2: flatMap (Java 9+)
List<String> result = optionalList.stream()
                                .flatMap(Optional::stream)
                                .collect(Collectors.toList());

嵌套 Optional 解包

Optional<Optional<String>> doubleOpt = Optional.of(Optional.of("value"));

// 解包方式1: flatMap
Optional<String> singleOpt = doubleOpt.flatMap(Function.identity());

// 解包方式2: Java 9+ or()方法
Optional<String> singleOpt = doubleOpt.or(Optional::empty);

反模式与优化

反模式示例

0. Optional作为字段

// 不好
class BadDesign {
    private Optional<String> name;
}

2. Optional作为参数

// 不好
public void process(Optional<String> input) {
    // 调用方仍然需要处理null
    // process(Optional.ofNullable(someString));
}

3. 不必要的Optional

// 不好 - 集合本身可以表示空
public Optional<List<String>> getNames() {
    return Optional.ofNullable(names);
}

优化建议

0. 使用空集合替代

// 好
public List<String> getNames() {
    return names != null ? names : Collections.emptyList();
}

2. 使用特定方法命名

// 好
public Optional<String> findNameById(Long id) {
    // 明确表示可能没有结果
}

3. 避免多层嵌套

// 不好
Optional<Optional<String>> bad = Optional.of(Optional.of("value"));

// 好
Optional<String> good = Optional.of("value");

异常处理

自定义业务异常

public class InsufficientBalanceException extends RuntimeException {
    public InsufficientBalanceException(String message) {
        super(message);
    }
}

// 使用示例
public Account deduct(Account account, BigDecimal amount) {
    return Optional.ofNullable(account)
                  .filter(a -> a.getBalance().compareTo(amount) >= 0)
                  .map(a -> {
                      a.setBalance(a.getBalance().subtract(amount));
                      return a;
                  })
                  .orElseThrow(() -> new InsufficientBalanceException(
                      "Insufficient balance for account: " + account.getId()));
}

多种异常类型处理

public User validateUser(Long userId) {
    return userRepository.findById(userId)
                       .filter(User::isActive)
                       .orElseThrow(() -> {
                           if (userId == null) {
                               return new IllegalArgumentException("User ID cannot be null");
                           } else {
                               return new UserNotFoundException(userId);
                           }
                       });
}

迁移建议

重构旧代码示例

重构前:

public String getCustomerName(Order order) {
    if (order != null && order.getCustomer() != null) {
        return order.getCustomer().getName();
    }
    return "Unknown";
}

重构后:

public String getCustomerName(Order order) {
    return Optional.ofNullable(order)
                  .map(Order::getCustomer)
                  .map(Customer::getName)
                  .orElse("Unknown");
}

保持向后兼容

// 旧方法
@Deprecated
public String oldMethod() {
    // 可能返回null
}

// 新方法
public Optional<String> newMethod() {
    String result = oldMethod();
    return Optional.ofNullable(result);
}

// 或者保持兼容
public String oldMethod() {
    return newMethod().orElse(null); // 不推荐，但有时必要
}

分阶段迁移策略

0. 首先在返回可能为null的方法中使用Optional
1. 逐步重构调用链，使用Optional的链式操作
2. 最后移除不必要的null检查
3. 对于关键API，同时提供Optional和非Optional版本

// 过渡期API设计
public String getName() {
    return name;
}

public Optional<String> getNameOpt() {
    return Optional.ofNullable(name);
}

总结

Optional 是 Java 8 引入的强大工具，用于更优雅地处理可能缺失的值。合理使用 Optional 可以:

0. 减少 NPE 风险
1. 使代码更清晰表达意图
2. 支持函数式编程风格
3. 强制调用方处理空值情况

然而，Optional 也不是万能的，应避免:

0. 过度使用导致代码复杂化
1. 作为字段或参数使用
2. 在性能关键路径上滥用
3. 替代必要的业务逻辑检查

希望本指南能帮助你掌握 Optional 的正确使用方式，写出更健壮、更易读的 Java 代码！

最后，祝大家心明眼亮，能在一堆废话里找到这句求关注。