在传统 Java 项目中，集合处理代码往往充斥着多层嵌套的循环、繁琐的空值判断以及高度耦合的业务逻辑。这类代码不仅冗长且难以维护，稍作修改便容易引入错误。事实上，这些问题均可借助函数式编程思想得到优雅解决。Java 8 引入的 Stream API 和 Optional 类为集合操作提供了更为声明式的处理方式。本文将从函数式视角出发，系统性介绍三类核心重构模式，助您以简洁、清晰的代码替代传统冗余实现，显著提升代码可读性与可维护性。
一、重构动因：传统集合操作与函数式编程的对比
在深入重构方法前，我们先通过一个典型场景来对比传统写法与函数式写法的差异，以明确重构的实际价值。
业务场景：从用户列表中筛选出年龄大于 18 岁、状态为“NORMAL”的用户，提取其用户名和手机号，转换为 UserDTO 列表并按年龄降序排序。
传统写法示例：
```java
public List<UserDTO> getValidUserDTOList(List<User> userList) {
List<UserDTO> result = new ArrayList<>();
if (userList != null && !userList.isEmpty()) {
for (User user : userList) {
if (user != null) {
if (user.getAge() > 18 && "NORMAL".equals(user.getStatus())) {
UserDTO dto = new UserDTO();
dto.setUserName(user.getUserName());
dto.setPhone(user.getPhone());
dto.setAge(user.getAge());
result.add(dto);
}
}
}
}
Collections.sort(result, new Comparator<UserDTO>() {
@Override
public int compare(UserDTO o1, UserDTO o2) {
return Integer.compare(o2.getAge(), o1.getAge());
}
});
return result;
}
```
传统写法存在以下明显不足：
- 代码冗长：简单操作需大量样板代码。
- 逻辑分散：初始化、遍历、条件判断、转换、排序等操作混杂，可读性差。
- 空值处理繁琐：多层 `if` 嵌套使代码臃肿且易遗漏判断。
- 维护困难：新人需逐行理解逻辑，修改时易出错。
函数式写法示例：
```java
public List<UserDTO> getValidUserDTOList(List<User> userList) {
return Optional.ofNullable(userList)
.orElseGet(Collections::emptyList)
.stream()
.filter(Objects::nonNull)
.filter(user -> user.getAge() > 18 && "NORMAL".equals(user.getStatus()))
.map(this::convertToUserDTO)
.sorted(Comparator.comparingInt(UserDTO::getAge).reversed())
.collect(Collectors.toList());
}
private UserDTO convertToUserDTO(User user) {
UserDTO dto = new UserDTO();
dto.setUserName(user.getUserName());
dto.setPhone(user.getPhone());
dto.setAge(user.getAge());
return dto;
}
```
函数式写法的优势：
- 代码简洁：链式调用将核心逻辑浓缩为数行。
- 逻辑连贯：操作顺序清晰，符合“数据流水线”思维。
- 职责单一：转换逻辑独立为方法，便于测试与复用。
- 空值安全：通过 `Optional` 和 `filter` 消除空指针隐患。
函数式集合操作的核心在于以声明式编程替代命令式编程：我们只需描述“做什么”，而非“怎么做”，从而更专注于业务逻辑本身。
二、核心重构模式
基于常见业务场景，我们总结了三类高频重构模式，可覆盖绝大多数集合处理需求。
模式一：空值安全处理（Stream + Optional）
适用场景：代码中存在多层集合与元素的空值判断。
重构思路：使用 `Optional` 包装可能为 `null` 的集合，使用 `filter(Objects::nonNull)` 过滤元素。
示例：获取未支付订单ID列表
```java
// 传统写法
public List<Long> getUnpaidOrderIds(List<Order> orderList) {
List<Long> unpaidIds = new ArrayList<>();
if (orderList != null) {
for (Order order : orderList) {
if (order != null && "UNPAID".equals(order.getStatus())) {
unpaidIds.add(order.getId());
}
}
}
return unpaidIds;
}
// 函数式重构
public List<Long> getUnpaidOrderIds(List<Order> orderList) {
return Optional.ofNullable(orderList)
.orElseGet(Collections::emptyList)
.stream()
.filter(Objects::nonNull)
.filter(order -> "UNPAID".equals(order.getStatus()))
.map(Order::getId)
.collect(Collectors.toList());
}
```
模式二：复杂聚合计算（Stream + Collectors）
适用场景：基于循环和临时变量实现的分组、统计、求和等操作。
重构思路：利用 `Collectors` 工具类实现聚合操作，避免手动管理中间状态。
示例：统计各省用户数量
```java
// 传统写法
public Map<String, Integer> countUserByProvince(List<User> userList) {
Map<String, Integer> provinceCountMap = new HashMap<>();
if (userList != null && !userList.isEmpty()) {
for (User user : userList) {
if (user != null && user.getAddress() != null) {
String province = user.getAddress().getProvince();
provinceCountMap.put(province, provinceCountMap.getOrDefault(province, 0) + 1);
}
}
}
return provinceCountMap;
}
// 函数式重构
public Map<String, Long> countUserByProvince(List<User> userList) {
return Optional.ofNullable(userList)
.orElseGet(Collections::emptyList)
.stream()
.filter(Objects::nonNull)
.filter(user -> user.getAddress() != null)
.map(user -> user.getAddress().getProvince())
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
}
```
模式三：多条件筛选与映射（Stream + Predicate/Function）
适用场景：不同业务场景下筛选条件或映射规则不同，导致代码重复。
重构思路：将条件与规则抽象为 `Predicate` 和 `Function` 参数，实现逻辑复用。
示例：通用筛选与转换方法
```java
public <R> List<R> filterAndMapUsers(List<User> userList,
Predicate<User> filterPredicate,
Function<User, R> mapFunction) {
return Optional.ofNullable(userList)
.orElseGet(Collections::emptyList)
.stream()
.filter(Objects::nonNull)
.filter(filterPredicate)
.map(mapFunction)
.collect(Collectors.toList());
}
// 使用示例：筛选成年正常用户
public List<UserDTO> getAdultNormalUsers(List<User> userList) {
return filterAndMapUsers(
userList,
user -> user.getAge() > 18 && "NORMAL".equals(user.getStatus()),
this::convertToUserDTO
);
}
```
三、最佳实践与注意事项
1. 谨慎使用并行流
仅在处理大数据集且操作耗时时考虑使用 `parallelStream()`。注意线程安全问题及上下文切换开销。
2. 避免在流中修改外部状态
函数式编程强调无副作用。应使用 `collect`、`reduce` 等操作替代对外部变量的修改。
3. 复杂逻辑应抽取为方法
过长的 Lambda 表达式会降低可读性。建议将复杂判断或转换逻辑抽取为独立方法，并通过方法引用调用。
4. 注意流的惰性求值特性
流的中间操作不会立即执行，直到遇到终止操作（如 `collect`）。确保流管道被正确触发。
四、总结
重构集合操作的本质是从命令式思维向声明式思维的转变。通过运用 Stream API 和 Optional，我们能够编写出更简洁、安全且易于维护的代码。对于开发者而言，掌握这些模式不仅能提升开发效率，还能减少潜在错误，使代码库更加健壮和优雅。建议在实际项目中逐步尝试应用这些模式，体会函数式编程带来的优势。
