Java Stream 在 6 个复杂业务场景下的高效实现方案

Stream 实现（JDK 17）

public static List<OrderVO> convertOrder2VO(List<Order> orderList) {
    return Optional.ofNullable(orderList)
            .stream()
            .flatMap(Collection::stream)
            // 1. 过滤订单：非空+2026 年 + 已支付 + 金额≥100
            .filter(Objects::nonNull)
            .filter(o -> LocalDate.of(2026, 1, 1).isBefore(o.getCreateTime().toLocalDate()))
            .filter(o -> "PAYED".equals(o.getStatus()))
            .filter(o -> o.getAmount().compareTo(new BigDecimal("100")) >= 0)
            // 2. 转换为 OrderVO，处理订单项
            .map(order -> {
                // 订单项转换 + 排序：非空 + 按单价倒序
                List<OrderItemVO> itemVOs = Optional.ofNullable(order.getItems())
                        .stream()
                        .flatMap(Collection::stream)
                        .filter(Objects::nonNull)
                        .sorted(Comparator.comparing(OrderItem::getPrice, Comparator.reverseOrder()))
                        .map(item -> new OrderItemVO(item.getProductName(), item.getQuantity(), item.getPrice()))
                        .toList();
                return new OrderVO(order.getOrderId(), order.getUserId(), order.getAmount(), itemVOs);
            })
            // 3. 过滤无订单项的订单 + 按订单金额倒序
            .filter(vo -> !vo.getItemVOs().isEmpty())
            .sorted(Comparator.comparing(OrderVO::getAmount, Comparator.reverseOrder()))
            .toList();
}

关键要点

1. 使用 Optional.ofNullable() + flatMap(Collection::stream) 处理集合为 null 的情况，比 Stream.ofNullable() 更适配集合场景；
2. **过滤操作前置：**先过滤订单，再处理订单项，减少后续数据转换量；
3. **多层排序按需执行：**订单项和订单的排序分别在各自的映射流程中完成，逻辑更清晰；
4. **JDK 8 适配：**将 toList() 替换为 StreamCompat.toList() ，Optional 的流式处理保持不变。

场景 2：用户数据 - 多维度分组 + 聚合统计

核心需求

从用户列表中按**用户等级（level）分组，再对每个分组按是否实名认证（isRealName）**二次分组，最终统计每个子分组的：

1. 用户总数；
2. 平均年龄；
3. 最大注册时间；
4. 有效用户数（年龄≥18 且手机号非空）。

数据模型

@Data
class User {
    private String userId;
    private Integer level; // 1-普通，2-会员，3-VIP
    private Boolean isRealName; // 实名认证
    private Integer age;
    private LocalDateTime registerTime;
    private String phone;
}

// 分组统计结果
@Data
@AllArgsConstructor
class UserGroupStats {
    private long totalCount; // 总数
    private double avgAge; // 平均年龄
    private LocalDateTime maxRegisterTime; // 最新注册时间
    private long validCount; // 有效用户数
}

Stream 实现（JDK 17）

public static Map<Integer, Map<Boolean, UserGroupStats>> statUserByGroup(List<User> userList) {
    return Optional.ofNullable(userList)
            .stream()
            .flatMap(Collection::stream)
            .filter(Objects::nonNull)
            // 1. 一级分组：level，二级分组：isRealName
            .collect(Collectors.groupingBy(
                    User::getLevel,
                    Collectors.groupingBy(
                            User::isRealName,
                            Collectors.collectingAndThen(
                                    Collectors.toList(),
                                    users -> {
                                        long totalCount = users.size();
                                        double avgAge = users.stream()
                                                .mapToInt(User::getAge)
                                                .average()
                                                .orElse(0.0);
                                        LocalDateTime maxRegisterTime = users.stream()
                                                .max(Comparator.comparing(User::getRegisterTime))
                                                .map(User::getRegisterTime)
                                                .orElse(null);
                                        long validCount = users.stream()
                                                .filter(u -> u.getAge() >= 18 && StringUtils.hasText(u.getPhone()))
                                                .count();
                                        return new UserGroupStats(totalCount, avgAge, maxRegisterTime, validCount);
                                    }
                            )
                    )
            ));
}