Java 具有相同内容的列表的内容总和

我有一份“详细信息”类型的分类列表，其内容如下：

[0]=Details test0: 28.01.2020
[0]=Details test1: 1234
[0]=Details test2: abcd
[0]=Details test3: 1
[0]=Details test4: 20.6
[0]=Details test5: 20.20

[1]=Details test0: 28.01.2020
[1]=Details test1: 1234
[1]=Details test2: abcd
[1]=Details test3: 1
[1]=Details test4: 20.6
[1]=Details test5: 20.20

[2]=Details test0: 29.01.2020
[2]=Details test1: 1234
[2]=Details test2: abcd
[2]=Details test3: 1
[2]=Details test4: 20.7
[2]=Details test5: 20.20

现在，排序列表返回所有这些对象，但我想用相同的test0、test1、test2和sum test3、test4和test5（test3+test3、test4+test4和test5+test5）对它们进行汇总：

我不确定

list.stream（）.filter

是否是解决此问题的最佳选项。有什么想法吗？ 应查找所有test0重复项的两种方法：

    public static List<Detail> getDuplicates(final List<Detail> list) {
    return getDuplicatesMap(list).values()
        .stream()
        .filter(duplicates -> duplicates.size() > 1)
        .flatMap(Collection::stream)
        .collect(Collectors.toList());
}

private static Map<String, List<Details>> getDuplicatesMap(List<Details> list) {
    return list.stream().collect(Collectors.groupingBy(Details::test0));
}

公共静态列表getDuplicates（最终列表）{
返回getDuplicatesMap（列表）.values（）
.stream（）
.filter（重复->重复.size（）>1）
.flatMap（集合：：流）
.collect（Collectors.toList（））；
}
私有静态映射getDuplicatesMap（列表）{
return list.stream（）.collect（Collectors.groupingBy（Details:：test0））；
}

在我们知道“属性总和”的含义之前，我所能做的就是给你一个简单的例子，说明如何对共享同一个“测试编号”的事物进行总和

final List<Details> detailses = ...; // Whatever you currently have.

detailses.stream()

        // Group by 'test number'.
        // This will return a Map<Integer, List<Details>>
        // The key is the test number, and the List contains all matching Details
        .collect(Collectors.groupingBy(Details::getTestNumber))

        // Stream over the entries of this grouped map
        .entrySet().stream()

        // And collect it to another Map
        .collect(Collectors.toMap(
            Map.Entry::getKey, // Keys stay the same

            // Values are mapped to the 'sum' of the properties...
            // However you choose to define that
            entry -> entry.getValue().stream()
                    .map(Details::getProperty)
                    .collect(/* Define summing the property here ... */)
        ));

最终列表详细信息=…；//无论你现在拥有什么。
detailses.stream（）
//按“测试编号”分组。
//这将返回一张地图
//键是测试编号，列表包含所有匹配的详细信息
.collect（收集器.groupingBy（详细信息：：getTestNumber））
//通过此分组映射的条目进行流式传输
.entrySet（）.stream（）
//然后把它收集到另一张地图上
.collect（collector.toMap）(
Map.Entry:：getKey，//键保持不变
//值映射到属性的“总和”。。。
//不管你如何定义它
entry->entry.getValue（）.stream（）
.map（详细信息：：getProperty）
.collect（/*在此处定义求和属性…*/）
));

---

这将产生一个

映射

，其中键是测试编号，值是该测试编号的

详细信息

的所有属性的“和”。

您要寻找的是基于几个属性合并重复条目，而不仅仅是识别重复项。将

Collectors.toMap

与

merge函数一起使用可以帮助您解决此问题

public static List<Details> getDuplicates(final List<Details> list) {
    return new ArrayList<>(list.stream()
            .collect(Collectors.toMap(dtl -> 
                            Arrays.asList(dtl.getTest0(), dtl.getTest1(), dtl.getTest2()), 
                    Function.identity(), Details::mergeDuplicates))
            .values());
}

请给我们看一些代码。另外，请解释“总结”的含义（例如）：28.01.2020+29.01.2020？abcd+abcd？20:38+20.6？请用有意义的名称命名变量，很难理解它们是什么
[2]=Details test4:20:38
您输入的数据正确吗？您计划如何添加这些？合并重复项将不起作用，因为它需要两个参数。@tamaramaria您在谈论哪两个参数？你是说两个
细节
对象吗？这就是为什么在使用方法引用表示的
toMap
中使用它。
收集器。toMap（…，Details:：mergeDuplicates）
将不起作用，因为它需要两个参数。@tamararia是根据方法引用推断的，它与read
（a，b）->Details几乎相同。mergeDuplicates（a，b）
@tamaramaria如果你注意到，在我的回答中，
分组方式是没有用的。我使用了
收集器.toMap
来收集。
public static List<Details> getDuplicates(final List<Details> list) {
    return new ArrayList<>(list.stream()
            .collect(Collectors.toMap(dtl -> 
                            Arrays.asList(dtl.getTest0(), dtl.getTest1(), dtl.getTest2()), 
                    Function.identity(), Details::mergeDuplicates))
            .values());
}

static Details mergeDuplicates(Details a, Details b) {
    return new Details(a.getTest0(), a.getTest1(), a.getTest2(),
            a.getTest3() + b.getTest3(), a.getTest4() + b.getTest4(), a.getTest5() + b.getTest5());
}