JDK8新特性-Optional

从 JDK7 的痛点理解 Optional

一、JDK7 时代，我们是怎么处理"可能为空"的值的？

假设你有一个方法，根据用户 ID 查询用户名：

// JDK7 风格 public String getUserName(Long userId) { User user = userDao.findById(userId); // 可能查不到，返回 null return user.getName(); // 如果 user 是 null，这里直接抛 NullPointerException }

这段代码在运行时，如果userId不存在，findById返回null，然后user.getName()就会抛出NullPointerException（NPE）。

所以 JDK7 的写法必须加上 null 检查：

public String getUserName(Long userId) { User user = userDao.findById(userId); if (user != null) { return user.getName(); } return "未知用户"; }

这看起来还行，对吧？但如果层级变深呢？

痛点 1：多层嵌套的 null 检查（金字塔灾难）

假设你要获取"用户的收货地址中的城市名称"：

public String getUserCity(Long userId) { User user = userDao.findById(userId); if (user != null) { Address address = user.getAddress(); if (address != null) { String city = address.getCity(); if (city != null) { return city; } } } return "未知城市"; }

这种代码被称为"箭头代码"或"死亡金字塔"：

• 缩进越来越深

• 可读性极差

• 核心业务逻辑（return city）被埋在层层判断的最深处

痛点 2：null 的含义模糊不清

在 JDK7 中，一个方法返回null，调用者根本搞不清楚：

• 是"查不到数据"所以返回 null？

• 还是"内部出错了"所以返回 null？

• 还是"参数传错了"所以返回 null？

null 成了一个"万能返回值"，但每个调用者都得猜它的含义，然后自己写防御代码。

痛点 3：容易忘记检查 null

人不是机器，总会忘记写if (x != null)。一个项目里几百个接口，只要有一个人忘记检查，线上就可能出现 NPE。

而且NPE 是运行时异常，编译器不会提醒你，只有跑到那行代码、恰好那个值是 null 时才会爆炸。这意味着很多 NPE bug 要上线后才发现。

二、Optional 的设计初衷：让"可能为空"这件事无法被忽略

Java 8 引入Optional<T>，核心目的只有一个：

在类型层面强制声明"这个值可能不存在"，让编译器和代码结构帮你记住这件事，而不是靠程序员的记忆力。

Optional 是什么？

你可以把它理解为一个包装盒子：

Optional<User> = 一个盒子，里面要么有一个 User 对象，要么是空的

一旦某个方法返回了Optional<User>，调用者看到这个返回值类型，就立刻明白：这里面的 User 可能不存在，我必须处理"不存在"的情况。

这和 JDK7 的区别在于：

三、Optional 的基本操作（从创建到使用）

3.1 创建 Optional：三种方式

方式一：Optional.of(value)——确定有值时使用

String name = "Alice"; Optional<String> opt = Optional.of(name); // 正常 // 如果你传了 null 进去： Optional<String> bad = Optional.of(null); // 立即抛出 NullPointerException

设计意图：of()用于那些你百分之百确定不会为 null的场景。

如果你误传了 null，它立刻爆炸，帮你把 bug 暴露在最早的地方，而不是等到后面才 NPE。

方式二：Optional.ofNullable(value)——值可能为 null 时使用

User user = userDao.findById(100L); // 可能返回 null Optional<User> opt = Optional.ofNullable(user);

如果user是 null，opt就是一个空盒子；如果有值，就是一个装了这个值的盒子。

这是从 JDK7 迁移到 Optional 时最常用的方法。

方式三：Optional.empty()—— 主动返回一个空盒子

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

这相当于你自己构造一个"无值"的状态。通常在方法内部逻辑判断后，决定返回空结果时使用。

3.2 取出值：为什么不要直接调用get()？

Optional 提供了一个get()方法取出里面的值：

Optional<String> opt = Optional.of("Hello"); String value = opt.get(); // "Hello"

但是，如果盒子是空的，调用get()会抛出NoSuchElementException。

这和 JDK7 的user.getName()在user为 null 时抛 NPE，本质上是一个问题：没有处理"空"的情况就直接拿值，还是会爆炸。

所以Java 8 设计 Optional 时，重点不是让你用get()，而是让你用下面这些方法安全地处理空盒子。

3.3 安全取值：orElse / orElseGet / orElseThrow

orElse(defaultValue)：如果盒子为空，返回默认值

Optional<User> opt = userDao.findById(100L); // 如果找到了，返回 user.getName()；如果没找到，返回 "未知用户" String name = opt.map(User::getName).orElse("未知用户");

设计意图：给出一个兜底的值，保证程序不会崩溃。

orElseGet(Supplier)：如果盒子为空，延迟计算默认值

String name = opt.map(User::getName) .orElseGet(() -> fetchNameFromCache()); // 只有为空时，才执行 fetchNameFromCache

为什么要设计orElseGet，而不是只用orElse？

因为orElse的参数是立即求值的。比如：

// 无论 opt 是否为空，createDefaultUser() 都会被执行 User user = opt.orElse(createDefaultUser());

如果createDefaultUser()内部要查数据库或做复杂计算，这就白白浪费了性能。orElseGet的参数是一个 Lambda，只有盒子真的为空时，才会执行。

orElseThrow()：如果盒子为空，抛出自定义异常

User user = opt.orElseThrow(() -> new RuntimeException("用户不存在，ID=" + userId));

设计意图：有些业务场景下，"查不到"本身就是错误，不能默默给个默认值，必须中断流程。这比 JDK7 时代手动if (user == null) throw new ...更简洁。

3.4 链式转换：map 和 flatMap（解决多层 null 检查的核心）

这是 Optional 最强大的地方，专门用来解决前面提到的"死亡金字塔"问题。

map()：如果盒子有值，就对其做转换，返回新的 Optional

Optional<User> userOpt = userDao.findById(100L); // 如果 userOpt 有值，取出 user.getName()，包装成 Optional<String> Optional<String> nameOpt = userOpt.map(user -> user.getName());

注意：map的返回值还是Optional，所以你可以链式调用：

// 获取"用户的地址的城市" String city = userDao.findById(100L) // Optional<User> .map(user -> user.getAddress()) // Optional<Address> .map(address -> address.getCity()) // Optional<String> .orElse("未知城市"); // 如果任何一步为空，直接返回默认值

对比一下 JDK7 的写法：

// JDK7：6 行，层层缩进 User user = userDao.findById(100L); if (user != null) { Address address = user.getAddress(); if (address != null) { String city = address.getCity(); if (city != null) { return city; } } } return "未知城市";

Optional 的链式调用把横向的层层 if 判断，转化成了纵向的流水线处理。

每一步的map都隐含了一个逻辑：如果上一步是空盒子，这一步自动跳过，不会抛 NPE。

flatMap()：当转换函数本身返回 Optional 时使用

假设userDao.findAddress(userId)返回的是Optional<Address>，而不是Address：

// ❌ 如果用 map，会得到 Optional<Optional<Address>>，嵌套了 Optional<Optional<Address>> nested = userOpt.map(user -> userDao.findAddress(user.getId())); // ✅ 用 flatMap，会把两层 Optional 压平成一层 Optional<Address> flat = userOpt.flatMap(user -> userDao.findAddress(user.getId()));

设计意图：flatMap解决的是"函数返回类型已经是 Optional"时的嵌套问题，保证链式调用的流畅性。

3.5 过滤：filter()

Optional<String> cityOpt = userDao.findById(100L) .map(User::getAddress) .map(Address::getCity) .filter(city -> !city.isEmpty()) // 如果城市名是空字符串，变成空 Optional .orElse("未知城市");

设计意图：在链式流程中加入条件判断，不满足条件就视为"无值"，统一走orElse的兜底逻辑。

四、一个完整的对比示例

假设需求：根据订单 ID 获取买家手机号，如果找不到订单、找不到买家、或者买家没填手机号，都返回"未绑定"。

JDK7 写法

public String getBuyerPhone(Long orderId) { Order order = orderDao.findById(orderId); if (order != null) { User buyer = userDao.findById(order.getBuyerId()); if (buyer != null) { String phone = buyer.getPhone(); if (phone != null && !phone.isEmpty()) { return phone; } } } return "未绑定"; }

JDK8 + Optional 写法

public String getBuyerPhone(Long orderId) { return orderDao.findById(orderId) // Optional<Order> .map(order -> userDao.findById(order.getBuyerId())) // 这里返回 Optional<User> .flatMap(userOpt -> userOpt) // 压平嵌套的 Optional .map(User::getPhone) // Optional<String> .filter(phone -> !phone.isEmpty()) // 过滤空字符串 .orElse("未绑定"); // 兜底 }

或者如果order.getBuyerId()查用户也返回 Optional：

public String getBuyerPhone(Long orderId) { return orderDao.findById(orderId) .flatMap(order -> userDao.findById(order.getBuyerId())) .map(User::getPhone) .filter(phone -> !phone.isEmpty()) .orElse("未绑定"); }

核心优势：

1. 没有缩进金字塔— 代码是扁平的

2. 没有 null 关键字— 全程看不到!= null的判断

3. 每一步的类型都是明确的— 你清楚地知道当前是Optional<Order>还是Optional<User>

4. 空值处理集中在最后— 所有"找不到"的情况，统一在orElse一处处理

五、设计 Optional 时的一些"规矩"

Java 8 设计 Optional 时，是有明确的使用规范的。违反这些规范，就失去了它的意义。

规矩 1：不要把 Optional 当作方法参数

// ❌ 错误示范 public void sendEmail(Optional<String> email) { // ... } // ✅ 正确做法：重载方法 public void sendEmail(String email) { // 正常发送 } public void sendEmail(String email, String defaultEmail) { // 带默认值的版本 }

为什么？因为Optional 是返回值类型的语义，表示"我（被调用方）可能给不出值"。

如果作为参数，相当于强迫调用方去构造 Optional，增加了调用方的负担，本末倒置。

规矩 2：不要用isPresent()+get()组合

// ❌ 这样写，和 JDK7 的 if-null 没区别，失去了 Optional 的意义 Optional<User> opt = userDao.findById(100L); if (opt.isPresent()) { User user = opt.get(); System.out.println(user.getName()); } else { System.out.println("未知用户"); } // ✅ 直接用 orElse 或 ifPresent opt.ifPresent(user -> System.out.println(user.getName())); String name = opt.map(User::getName).orElse("未知用户");

规矩 3：不要把 Optional 作为类的字段或集合元素

// ❌ 不推荐 public class User { private Optional<String> email; // 字段不要用 Optional private List<Optional<Order>> orders; // 集合里也不要放 Optional } // ✅ 正确做法 public class User { private String email; // 字段保持 nullable public Optional<String> getEmail() { return Optional.ofNullable(email); // 在 getter 中包装 } }

为什么？因为 Optional 不是为序列化设计的，也不适合长期存储。它应该只存在于方法调用的局部流程中，作为"从查询到使用"这个短暂过程中的类型约束。

六、总结：Optional 解决了什么问题？

Optional 的本质不是消灭 null，而是把"可能为空"从"隐式的约定"变成"显式的类型约束"，让编译器和代码结构帮你守住防线，而不是靠人的记忆力。

Map() 、flatMap()对Optinal的处理

map和flatMap不只是集合专属，Optional自己也有这两个方法，名字一样，但操作的对象完全不同。

一、熟悉的map：Stream/Collection 里的版本

在 JDK7 里，你操作集合是这样的：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); // JDK7：循环遍历，逐个转换 List<Integer> lengths = new ArrayList<>(); for (String name : names) { lengths.add(name.length()); // 对集合里的"每个元素"做转换 }

JDK8 的 Stream 给你提供了map，做的是同样的事：

List<Integer> lengths = names.stream() .map(name -> name.length()) // 对 Stream 里的"每一个元素"做转换 .collect(Collectors.toList());

这里的map操作的是一组数据，输入 3 个字符串，输出 3 个整数。

二、Optional 的map：操作的是"一个值"，不是"一组值"

Optional 不是集合，它里面最多只装一个对象，或者什么都没有。

但 Optional 也提供了map，它的逻辑和 Stream 的map语义是相通的：

如果容器里有值，就对这个值做转换，然后把结果重新包起来返回。

只不过 Stream 里可能转换了 100 个元素，Optional 里最多转换 1 个元素。

看Optional.map的源码逻辑（我简化后）：

public <U> Optional<U> map(Function<? super T, ? extends U> mapper) { if (!isPresent()) { // 如果盒子是空的 return empty(); // 直接返回空盒子 } else { return Optional.ofNullable(mapper.apply(value)); // 把值拿出来转换，再包成新盒子 } }

对比一下你就明白了：

三、代码对比：让你看到本质区别

// ========== Stream.map：处理多个 ========== List<String> names = Arrays.asList("Alice", "Bob"); List<Integer> result = names.stream() .map(name -> name.length()) // "Alice"→5, "Bob"→3，转换了两次 .collect(Collectors.toList()); // 结果：[5, 3] // ========== Optional.map：处理一个（或零个） ========== Optional<String> nameOpt = Optional.of("Alice"); Optional<Integer> result = nameOpt .map(name -> name.length()); // "Alice"→5，只转换了一次 // 结果：Optional[5] // 如果 Optional 是空的： Optional<String> emptyOpt = Optional.empty(); Optional<Integer> result2 = emptyOpt .map(name -> name.length()); // 发现是空的，跳过转换，直接返回 Optional.empty // 结果：Optional.empty

所以回到你的问题：

userDao.findById(100L)不是得到的一个 user 对象吗，怎么能用 map 处理呢？

它返回的不是User，而是Optional<User>。这个Optional是一个容器盒子，map是这个盒子提供的方法，用来转换盒子里的那个User。

Optional<User> userOpt = userDao.findById(100L); // 这是一个盒子 Optional<String> nameOpt = userOpt.map(user -> user.getName()); // ↑ 盒子 ↑ 盒子的方法 ↑ 盒子里的 User 对象

四、为什么要用同一个名字map？

Java 8 引入函数式编程时，设计了一个统一的概念叫Functor（函子）。理解它的核心思想：

任何一个"能装东西的容器"，都应该提供map方法，让你对"里面的内容"做转换，而不用关心容器本身的结构。

在 Java 8 里，至少有这几个类实现了这个思想：

它们都叫map，是因为语义完全一致："容器负责保管值，你负责告诉我怎么转换值，容器负责把转换后的结果重新包起来。"

这样你学会了一个类的map，其他类的map自然就懂了。

五、flatMap同理：解决"套娃"问题

你熟悉的情况可能是：

List<List<Integer>> nested = Arrays.asList( Arrays.asList(1, 2), Arrays.asList(3, 4) ); // flatMap：把嵌套的 List 压平成一个 List List<Integer> flat = nested.stream() .flatMap(list -> list.stream()) // List<List> → List .collect(Collectors.toList()); // 结果：[1, 2, 3, 4]

Optional 的flatMap也是同样的语义：压平嵌套的 Optional。

// 假设 userDao.findById 返回 Optional<User> // 假设 addressDao.findByUserId 返回 Optional<Address> Optional<User> userOpt = userDao.findById(100L); // ❌ 如果用 map，会得到 Optional<Optional<Address>>，套了两层盒子 Optional<Optional<Address>> nested = userOpt.map( user -> addressDao.findByUserId(user.getId()) ); // ✅ 用 flatMap，会把两层压平成一层 Optional<Address> Optional<Address> flat = userOpt.flatMap( user -> addressDao.findByUserId(user.getId()) );

对比：

六、一句话总结

map/flatMap不是集合的专利，它是"容器"的通用操作。

• Stream 是装多个值的容器，map转换每一个值。

• Optional 是装零个或一个值的容器，map转换那个值（如果有的话）。