java - 合并具有相同日期和 ID 的两个列表中的所有元素并总结它们的成本

Question

我们在 Java 中有两个列表，如下所示。我需要从这两个列表中获取所有元素，如果有相同的 id 和相同的 date，我们需要对这些列表中这些元素的 cost 求和。

List<A> listA = new ArrayList<>();
List<A> listB = new ArrayList<>();
List<A> results = new ArrayList<>();

列表A:

<表类="s-表"><头>编号<日>日期 费用<正文>12022-01-0111.6522022-02-0112.6522022-03-0113.6532022-05-0119.5

列表B:

<表类="s-表"><头>编号<日>日期 费用<正文>12022-04-011.6512022-05-01134.6522022-02-0112.6522022-09-017.832022-06-013.65

结果应该是

结果列表应该是->

<表类="s-表"><头>编号<日>日期 费用<正文>12022-01-0111.6512022-04-011.6512022-05-01134.6522022-02-0125.3*22022-03-0113.6522022-09-017.832022-05-0119.532022-06-013.65

*(listA.cost + listB.cost 这是基于日期条件和id)

到目前为止我试过的是这个

Stream.concat(
        listA.stream().map(d -> new Result(d.getId(), d.getDate()), d.getCost()),
        listB.stream().map(b -> new Result(b.getId(), b.getDate(), b.getCost())
    )
    .collect(Collectors.toList());

我能够获取所有数据，但在这一步之后我需要获取所有数据，如果有相同的 date 和相同的 id 我们需要总结listA 的 cost 与 listB

的成本

Answer 1

get all the data and if there is same date and same id we need to sum up the cost from listA with the cost of listB

可以通过将这些列表中的数据分组到中间映射中来实现。该映射的键应该是一个能够合并 date 和 id 的对象。有几种快速而肮脏的方法，例如将它们连接为字符串，但正确的方法是定义一个记录(或一个类)。中间映射的值将表示映射到 date 和 id 的相同组合的成本总和。

然后我们可以在辅助映射的条目上创建一个流，将每个条目变成一个对象 A 并收集到一个列表中。

这就是它的实现方式。

定义一个 record , IdDate, 用作键:

public record IdDate(long id, LocalDate date) {}

List<A> listA =
    Arrays.asList(new A(1, LocalDate.parse("2022-01-01"), 11.65), // for Java 9+ use - List.of()
                  new A(2, LocalDate.parse("2022-02-01"), 12.65),
                  new A(2, LocalDate.parse("2022-03-01"), 13.65),
                  new A(3, LocalDate.parse("2022-05-01"), 19.5));
        
List<A> listB =
    Arrays.asList(new A(1, LocalDate.parse("2022-04-01"), 1.65), // for Java 9+ use - List.of()
                  new A(1, LocalDate.parse("2022-05-01"), 134.65),
                  new A(2, LocalDate.parse("2022-02-01"), 12.65),
                  new A(2, LocalDate.parse("2022-09-01"), 7.8),
                  new A(3, LocalDate.parse("2022-06-01"), 3.65));

List<A> results = 
    Stream
    .concat(listA.stream(), listB.stream())
    .collect(
        Collectors.groupingBy(                       // creating an intermediate map `Map<IdDate, Double>`
            a -> new IdDate(a.getId(), a.getDate()), // classifier fuction - generating a key
            Collectors.summingDouble(A::getCost)     // downstream collector - combining values mapped to the same key
        )
    )
    .entrySet()
    .stream()
    .map(entry -> new A(entry.getKey().id(),     // transforming an entry into an object `A`
                        entry.getKey().date(),
                        entry.getValue()))
    .toList();                                   // In earlier Java: .collect(Collectors.toList());
    
results.forEach(System.out::println);

输出:

A{id=2, date=2022-09-01, cost=7.8}
A{id=2, date=2022-03-01, cost=13.65}
A{id=2, date=2022-02-01, cost=25.3}
A{id=3, date=2022-06-01, cost=3.65}
A{id=3, date=2022-05-01, cost=19.5}
A{id=1, date=2022-05-01, cost=134.65}
A{id=1, date=2022-04-01, cost=1.65}
A{id=1, date=2022-01-01, cost=11.65}

A link to Online Demo