Java中高效关联父子列表：利用HashMap优化数据映射

在企业级应用开发中，我们经常会遇到需要将相关联的数据集合进行匹配和组装的场景。例如，一个产品（Product）可能包含多个子产品线（ProductSub）。当我们需要将所有子产品线正确地关联到其对应的父产品时，选择一个高效的算法至关重要。

业务场景与初始实现分析

假设我们定义了两个Java类来表示产品及其子产品线：

public class Product {
    private long productId;
    private String productName;
    private BigDecimal costAmount;
    private List productSublist; // 子产品线列表

    // 构造函数、Getter和Setter略
    public long getProductId() { return productId; }
    public void setProductSublist(List productSublist) { this.productSublist = productSublist; }
}

public class ProductSub {
    private long productId; // 关联的父产品ID
    private long productSubId;
    private String lineItemName;
    private BigDecimal subCost;

    // 构造函数、Getter和Setter略
    public long getProductId() { return productId; }
}

我们的目标是将一个包含所有ProductSub对象的扁平列表，根据productId关联到相应的Product对象中。一个常见的、直观的实现方式如下：

List productList = /* 从服务获取的产品列表 */;
List productSubList = /* 从服务获取的子产品列表 */;

for (Product productItem : productList){
    // 对于每个产品，遍历并过滤整个子产品列表
    List productSubItems = productSubList.stream()
       .filter(x -> x.getProductId() == productItem.getProductId())
       .collect(Collectors.toList());
    productItem.setProductSubList(productSubItems);
}

这段代码的逻辑是：遍历主产品列表productList中的每一个Product对象，然后针对当前Product的productId，对整个productSubList进行一次过滤，收集所有匹配的ProductSub对象，并将其设置到Product的productSublist属性中。

立即学习“Java免费学习笔记（深入）”；

性能分析： 这种方法的缺点在于其时间复杂度。假设productList有n个元素，productSubList有m个元素。外层循环会执行n次。在每次外层循环中，stream().filter().collect()操作会遍历（或至少部分遍历）productSubList，其时间复杂度近似为O(m)。因此，整体的时间复杂度为O(n * m)。当n和m都很大时，这种方法会变得非常低效。

优化方案：基于HashMap的预聚合

为了提高效率，我们可以改变处理数据的策略：不再为每个父产品重复遍历整个子产品列表，而是先对子产品列表进行一次预处理，将其按productId分组，存储在一个HashMap中。这样，在遍历父产品列表时，可以直接通过productId从HashMap中快速查找对应的子产品列表。

优化后的实现代码如下：

Codiga

可自定义的静态代码分析检测工具

下载

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors; // 如果需要使用stream()来初始化map，但更推荐computeIfAbsent

// 假设 productList 和 productSubList 已经初始化

Map> productSubMap = new HashMap<>();

// 步骤1：遍历子产品列表，按productId进行分组并存储到HashMap中
for (ProductSub productSub : productSubList) {
  productSubMap.computeIfAbsent(productSub.getProductId(), k -> new ArrayList<>()).add(productSub);
}

// 步骤2：遍历主产品列表，从HashMap中获取对应的子产品列表
for (Product product : productList) {
  // 从map中获取子产品列表，如果不存在则设为空列表
  product.setProductSubList(productSubMap.getOrDefault(product.getProductId(), new ArrayList<>()));
}

代码解析：

1. Map> productSubMap = new HashMap();: 创建一个HashMap，键是productId（Long类型），值是对应的ProductSub对象列表。
2. productSubMap.computeIfAbsent(productSub.getProductId(), k -> new ArrayList()).add(productSub);: 这是Java 8 Map接口提供的一个非常方便的方法。
   • 它尝试获取productSub.getProductId()对应的键的值。
   • 如果键不存在，它会使用提供的mappingFunction（k -> new ArrayList()）来创建一个新的ArrayList，并将其与该键关联，然后返回这个新创建的ArrayList。
   • 如果键已经存在，它会直接返回已存在的ArrayList。
   • 无论哪种情况，返回的ArrayList都会被add(productSub)操作添加当前的productSub对象。 通过这个操作，我们只需要一次遍历productSubList就能完成所有子产品的分组。
3. product.setProductSubList(productSubMap.getOrDefault(product.getProductId(), new ArrayList()));: 在遍历productList时，我们使用getOrDefault方法从productSubMap中获取子产品列表。如果某个productId在productSubMap中没有对应的条目（即该产品没有子产品），getOrDefault会返回一个空的ArrayList，确保productSublist不会是null，提高了代码的健壮性。

性能考量与复杂度分析

让我们再次分析优化后的时间复杂度：

• 步骤1（构建productSubMap）：遍历productSubList一次，每次操作（computeIfAbsent和add）在HashMap的平均情况下是O(1)。因此，这一步的时间复杂度为O(m)。
• 步骤2（关联子列表到父产品）：遍历productList一次，每次操作（getOrDefault和setProductSubList）在HashMap的平均情况下是O(1)。因此，这一步的时间复杂度为O(n)。

综合来看，优化后的整体时间复杂度为O(m + n)。

对比总结：

• 初始方法： O(n * m)
• 优化方法： O(n + m)

显然，O(n + m)在n和m较大时，性能远优于O(n * m)。例如，如果n=1000，m=10000：

• 初始方法需要约1000 * 10000 = 10,000,000次操作。
• 优化方法需要约1000 + 10000 = 11,000次操作。 性能提升是数量级的。

注意事项

1. 内存消耗： HashMap会占用额外的内存来存储键值对。对于非常庞大的数据集，需要权衡内存使用和性能提升。但通常情况下，这种权衡是值得的。
2. 键的唯一性与哈希码： HashMap的性能高度依赖于键（productId）的hashCode()和equals()方法的实现。对于基本类型Long，Java已经处理得很好。
3. 空列表处理： 使用getOrDefault(key, new ArrayList())是一个良好的实践，可以避免NullPointerException，并确保Product的productSublist字段始终是一个非空的列表（即使是空列表），简化后续处理。
4. 线程安全： 如果在多线程环境中构建或访问productSubMap，需要考虑同步机制，例如使用ConcurrentHashMap或通过其他方式确保线程安全。在上述单线程场景中，HashMap是完全适用的。

总结

在处理Java集合数据关联时，选择合适的算法和数据结构能够显著提升应用程序的性能。当面临需要将一个大列表中的元素根据某个键分组并关联到另一个列表的场景时，利用HashMap进行预聚合是一个非常有效的优化策略。通过将时间复杂度从O(n*m)优化到O(n+m)，我们可以避免重复遍历，从而在处理大量数据时获得数量级的性能提升。理解并应用这种模式，是编写高效、健壮Java代码的关键技能之一。