JavaScript中如何匹配两个对象数组并重构订单数组？

核心思路 #

先将包裹价格数组转换为以packageId为键的映射结构（如Map/哈希表），实现单价的快速查找，避免嵌套循环带来的性能损耗；之后遍历原订单数组，将每个订单项与映射中的单价合并，生成包含单价的新订单数组。

JavaScript 实现示例 #

// 原始订单数组
const order = [{ packageId: 'pkg001', quantity: 2 }, { packageId: 'pkg002', quantity: 5 }];
// 从数据库获取的包裹价格数组
const packagePrice = [{ packageId: 'pkg001', unitPrice: 19.99 }, { packageId: 'pkg002', unitPrice: 29.99 }];

// 1. 构建价格映射表
const priceMap = new Map(packagePrice.map(item => [item.packageId, item.unitPrice]));

// 2. 生成包含单价的新订单数组
const updatedOrder = order.map(item => ({
  ...item,
  UnitPrice: priceMap.get(item.packageId) // 匹配对应单价，键名与需求示例一致
}));

console.log(updatedOrder);
// 输出：[{ packageId: 'pkg001', quantity: 2, UnitPrice: 19.99 }, { packageId: 'pkg002', quantity: 5, UnitPrice: 29.99 }]

异常场景处理（可选） #

若packagePrice中存在未覆盖的packageId，可根据业务需求添加处理逻辑：

const updatedOrder = order.map(item => {
  const unitPrice = priceMap.get(item.packageId);
  if (unitPrice === undefined) {
    // 此处可选择抛出错误、设默认值或标记异常
    throw new Error(`未找到包裹 ${item.packageId} 的价格信息`);
  }
  return {
    ...item,
    UnitPrice: unitPrice
  };
});

Java 实现示例 #

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// 包裹价格实体类
class PackagePrice {
    private String packageId;
    private double unitPrice;

    public PackagePrice(String packageId, double unitPrice) {
        this.packageId = packageId;
        this.unitPrice = unitPrice;
    }

    public String getPackageId() { return packageId; }
    public double getUnitPrice() { return unitPrice; }
}

// 订单项实体类
class OrderItem {
    private String packageId;
    private int quantity;
    private double UnitPrice;

    public OrderItem(String packageId, int quantity) {
        this.packageId = packageId;
        this.quantity = quantity;
    }

    public String getPackageId() { return packageId; }
    public int getQuantity() { return quantity; }
    public void setUnitPrice(double unitPrice) { UnitPrice = unitPrice; }

    @Override
    public String toString() {
        return "OrderItem{" +
                "packageId='" + packageId + '\'' +
                ", quantity=" + quantity +
                ", UnitPrice=" + UnitPrice +
                '}';
    }
}

public class OrderProcessor {
    public static void main(String[] args) {
        // 原始订单列表
        List<OrderItem> order = new ArrayList<>();
        order.add(new OrderItem("pkg001", 2));
        order.add(new OrderItem("pkg002", 5));

        // 数据库获取的包裹价格列表
        List<PackagePrice> packagePrice = new ArrayList<>();
        packagePrice.add(new PackagePrice("pkg001", 19.99));
        packagePrice.add(new PackagePrice("pkg002", 29.99));

        // 1. 构建价格映射
        Map<String, Double> priceMap = new HashMap<>();
        for (PackagePrice price : packagePrice) {
            priceMap.put(price.getPackageId(), price.getUnitPrice());
        }

        // 2. 生成新订单列表
        List<OrderItem> updatedOrder = new ArrayList<>();
        for (OrderItem item : order) {
            OrderItem updatedItem = new OrderItem(item.getPackageId(), item.getQuantity());
            updatedItem.setUnitPrice(priceMap.get(item.getPackageId()));
            updatedOrder.add(updatedItem);
        }

        // 输出结果
        updatedOrder.forEach(System.out::println);
    }
}

性能说明 #

该实现的时间复杂度为O(n + m)，其中n为订单数组长度，m为包裹价格数组长度，相比嵌套循环的O(n*m)，在数据量较大时性能优势显著。

内容的提问来源于stack exchange，提问作者Firas SCMP