
在业务开发中,我们经常会遇到需要将关联的子项列表数据附加到其父项对象中的场景。例如,我们有product(产品)和productsub(产品子项)两种实体,一个product可以拥有多个productsub。假设我们已经从服务层获取到两个独立的列表:list<product>和list<productsub>,现在需要将每个product对应的productsub列表设置到其productsublist属性中。
以下是相关的类定义:
public class Product {
private long productId;
private String productName;
private BigDecimal costAmount;
private List<ProductSub> 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<ProductSub> productSublist) { this.productSublist = productSublist; }
public List<ProductSub> 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 已从服务获取
List<Product> productList = new ArrayList<>(); // ... (填充数据)
List<ProductSub> productSubList = new ArrayList<>(); // ... (填充数据)
for (Product productItem : productList){
// 对于每个产品,遍历并过滤整个产品子项列表
List<ProductSub> productSubItems = productSubList.stream()
.filter(x -> x.getProductId() == productItem.getProductId())
.collect(Collectors.toList());
productItem.setProductSubList(productSubItems);
}上述初始实现虽然逻辑清晰,但在处理大规模数据时会面临严重的性能问题。其时间复杂度为O(N * M),其中N是productList中的产品数量,M是productSubList中的产品子项数量。
具体分析如下:
立即学习“Java免费学习笔记(深入)”;
当N和M都很大时(例如,N=10000,M=100000),N * M = 1,000,000,000,这将导致非常长的执行时间,严重影响应用程序的响应性能。
为了显著提升性能,我们可以采用基于哈希映射(HashMap)的数据预处理策略。核心思想是:将productSubList一次性转换为一个Map<Long, List<ProductSub>>,其中Map的键是productId,值是该productId对应的所有ProductSub对象的列表。
利用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<Product> 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<ProductSub> 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<Long, List<ProductSub>> 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<ProductSub> 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优化后,算法的时间复杂度显著降低:
因此,总的时间复杂度为O(M + N)。
对比:
当N和M都很大时,O(N + M)的性能优势是压倒性的。例如,如果N=10000,M=100000,原始方案需要约10亿次操作,而优化方案只需要约11万次操作,性能提升了数千倍。
在Java中处理父子列表关联的场景时,从简单直观的嵌套循环过滤到基于Map的数据预处理,是提升性能的关键优化手段。通过将时间复杂度从O(N * M)降低到O(N + M),我们可以显著提高大规模数据处理的效率。理解并应用这种优化模式,对于编写高性能、可扩展的Java应用程序至关重要。始终在性能和代码可读性之间找到平衡,并根据实际数据量和业务需求选择最合适的策略。
以上就是Java中高效关联父子列表数据:从O(NM)到O(N+M)的优化实践的详细内容,更多请关注php中文网其它相关文章!
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移,垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是,许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号