场景描述与初始实现
在业务开发中，我们经常会遇到需要将关联的子项列表数据附加到其父项对象中的场景。例如，我们有product（产品）和productsub（产品子项）两种实体，一个product可以拥有多个productsub。假设我们已经从服务层获取到两个独立的列表：list
以下是相关的类定义：
public class Product {
private long productId;
private String productName;
private BigDecimal costAmount;
private List productSublist; // 用于存储子项列表
// 构造函数、Getter和Setter（此处省略）
public Product(long productId, String productName, BigDecimal costAmount) {
this.productId = productId;
this.productName = productName;
this.costAmount = costAmount;
this.productSublist = new ArrayList<>();
}
public long getProductId() { return productId; }
public void setProductSublist(List productSublist) { this.productSublist = productSublist; }
public List getProductSublist() { return productSublist; }
}
public class ProductSub {
private long productId; // 与Product关联的ID
private long productSubId;
private String lineItemName;
private BigDecimal subCost;
// 构造函数、Getter和Setter（此处省略）
public ProductSub(long productId, long productSubId, String lineItemName, BigDecimal subCost) {
this.productId = productId;
this.productSubId = productSubId;
this.lineItemName = lineItemName;
this.subCost = subCost;
}
public long getProductId() { return productId; }
} 一种常见的直观实现方式是遍历Product列表，在每次迭代中，通过流式API过滤整个ProductSub列表，找到与当前Product匹配的子项，然后收集起来并设置到Product对象中。
// 假设 productList 和 productSubList 已从服务获取 ListproductList = new ArrayList<>(); // ... (填充数据) List productSubList = new ArrayList<>(); // ... (填充数据) for (Product productItem : productList){ // 对于每个产品，遍历并过滤整个产品子项列表 List productSubItems = productSubList.stream() .filter(x -> x.getProductId() == productItem.getProductId()) .collect(Collectors.toList()); productItem.setProductSubList(productSubItems); }
性能瓶颈分析
上述初始实现虽然逻辑清晰，但在处理大规模数据时会面临严重的性能问题。其时间复杂度为O(N * M)，其中N是productList中的产品数量，M是productSubList中的产品子项数量。
具体分析如下：
立即学习“Java免费学习笔记（深入）”；
- 外层循环：for (Product productItem : productList) 会执行N次。
- 内层操作：在每次外层循环中，productSubList.stream().filter(...).collect(...) 会对整个productSubList（M个元素）进行一次完整的遍历和过滤操作。
- 因此，总的操作次数近似于 N * M。
当N和M都很大时（例如，N=10000，M=100000），N * M = 1,000,000,000，这将导致非常长的执行时间，严重影响应用程序的响应性能。
优化策略：基于Map的数据预处理
为了显著提升性能，我们可以采用基于哈希映射（HashMap）的数据预处理策略。核心思想是：将productSubList一次性转换为一个Map
利用Map的优势在于其平均O(1)的查找时间复杂度。通过这种方式，我们只需要遍历productSubList一次来构建Map，然后再遍历productList一次来从Map中获取对应的子项列表。
以下是优化后的代码示例：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.math.BigDecimal; // 确保导入BigDecimal
public class ProductAssociationOptimizer {
public static void main(String[] args) {
// 模拟数据
List productList = new ArrayList<>();
productList.add(new Product(1L, "Laptop", new BigDecimal("1200.00")));
productList.add(new Product(2L, "Mouse", new BigDecimal("25.00")));
productList.add(new Product(3L, "Keyboard", new BigDecimal("75.00")));
List productSubList = new ArrayList<>();
productSubList.add(new ProductSub(1L, 101L, "CPU", new BigDecimal("500.00")));
productSubList.add(new ProductSub(1L, 102L, "RAM", new BigDecimal("150.00")));
productSubList.add(new ProductSub(2L, 201L, "Optical Sensor", new BigDecimal("10.00")));
productSubList.add(new ProductSub(1L, 103L, "SSD", new BigDecimal("200.00")));
productSubList.add(new ProductSub(3L, 301L, "Mechanical Switch", new BigDecimal("30.00")));
productSubList.add(new ProductSub(2L, 202L, "Scroll Wheel", new BigDecimal("5.00")));
productSubList.add(new ProductSub(4L, 401L, "Unmatched Sub", new BigDecimal("10.00"))); // 模拟一个没有对应产品ID的子项
// 优化后的数据关联方法
Map> productSubMap = new HashMap<>();
// 第一次遍历：构建Map
for (ProductSub productSub : productSubList) {
// computeIfAbsent 是一个非常方便的方法
// 如果键不存在，则创建一个新的ArrayList并放入Map，然后将当前productSub添加到该列表中
// 如果键已存在，则直接获取对应的List并添加当前productSub
productSubMap.computeIfAbsent(productSub.getProductId(), k -> new ArrayList<>()).add(productSub);
}
// 第二次遍历：将子列表设置到父产品中
for (Product product : productList) {
// 从Map中获取对应的子列表，O(1)操作
List subs = productSubMap.get(product.getProductId());
// 注意处理subs可能为null的情况，如果某个产品没有对应的子项
product.setProductSublist(subs != null ? subs : new ArrayList<>());
}
// 验证结果
for (Product product : productList) {
System.out.println("Product: " + product.getProductName() + " (ID: " + product.getProductId() + ")");
if (product.getProductSublist().isEmpty()) {
System.out.println(" No sub-items.");
} else {
for (ProductSub sub : product.getProductSublist()) {
System.out.println(" - Sub-item: " + sub.getLineItemName() + " (SubID: " + sub.getProductSubId() + ")");
}
}
}
}
} 在上述代码中，map.computeIfAbsent(productSub.getProductId(), k -> new ArrayList()).add(productSub); 这一行是关键。它利用Java 8的Map接口提供的computeIfAbsent方法，优雅地处理了当键不存在时创建新列表并添加元素，以及键已存在时直接获取列表并添加元素的逻辑，避免了手动检查containsKey和get。
复杂度对比与优势
通过Map优化后，算法的时间复杂度显著降低：
- 第一次遍历productSubList（M个元素）以构建Map：O(M)
- 第二次遍历productList（N个元素）并从Map中查找：O(N * 1) = O(N) (因为Map查找是O(1)平均时间复杂度)
因此，总的时间复杂度为O(M + N)。
对比：
- 原始方案： O(N * M)
- 优化方案： O(N + M)
当N和M都很大时，O(N + M)的性能优势是压倒性的。例如，如果N=10000，M=100000，原始方案需要约10亿次操作，而优化方案只需要约11万次操作，性能提升了数千倍。
注意事项与最佳实践
- 内存开销： 使用Map会占用额外的内存来存储productSubMap。对于极大规模的ProductSub列表，如果内存成为瓶颈，可能需要考虑分批处理或其他更高级的策略。但在大多数业务场景下，这种内存开销是可接受的，并且与性能提升相比是值得的。
- 键的唯一性与hashCode/equals： 确保用作Map键的对象（此处是Long类型的productId）正确实现了hashCode()和equals()方法。对于基本类型包装类如Long，Java已经处理得很好。如果是自定义对象作为键，则需特别注意。
- 空值处理： 在product.setProductSublist(productSubMap.get(product.getProductId()));这一步，如果某个Product的productId在productSubMap中不存在（即该产品没有子项），productSubMap.get()将返回null。此时，应将Product的productSublist设置为一个空的ArrayList，而不是null，以避免后续操作时出现NullPointerException。示例代码中已通过三元运算符subs != null ? subs : new ArrayList()进行了处理。
- 线程安全： 如果在多线程环境中并发地进行这种数据关联操作，需要确保对Map和`List的操作是线程安全的。例如，可以使用ConcurrentHashMap或在操作前对数据进行同步。但对于一次性的数据加载和处理，通常不需要额外考虑线程安全。
- 数据源： 确保productId在Product和ProductSub中是正确关联的键。如果关联键是复合的，Map的键也需要相应地调整（例如，使用自定义的复合键对象或字符串拼接）。
总结
在Java中处理父子列表关联的场景时，从简单直观的嵌套循环过滤到基于Map的数据预处理，是提升性能的关键优化手段。通过将时间复杂度从O(N * M)降低到O(N + M)，我们可以显著提高大规模数据处理的效率。理解并应用这种优化模式，对于编写高性能、可扩展的Java应用程序至关重要。始终在性能和代码可读性之间找到平衡，并根据实际数据量和业务需求选择最合适的策略。
