基于流中的另一个字段总结字段[重复]

Question

我有一个如下所示的对象列表：

{
    value=500
    category="GROCERY"
},
{
    value=300
    category="GROCERY"
},
{
    value=100
    category="FUEL"
},
{
    value=300
    category="SMALL APPLIANCE REPAIR"
},
{
    value=200
    category="FUEL"
}

我想将其转换为如下所示的对象列表：

{
    value=800
    category="GROCERY"
},
{
    value=300
    category="FUEL"
},
{
    value=300
    category="SMALL APPLIANCE REPAIR"
}

基本上把所有同类别的值加起来。

我应该使用 flatMap 吗？减少？我不明白这些的细微差别要弄清楚。

帮助？

编辑：

这个问题有很多重复： Is there an aggregateBy method in the stream Java 8 api? 和 Sum attribute of object with Stream API

但在这两种情况下，最终结果都是地图，而不是列表

根据@AndrewTobilko 和@JBNizet 的回答，我使用的最终解决方案是：

List<MyClass> myClassList = list.stream()
    .collect(Collectors.groupingBy(YourClass::getCategory,
                    Collectors.summingInt(YourClass::getValue)))
    .entrySet().stream().map(e -> new MyClass(e.getKey(), e.getValue()).collect(toList());

Answer 1

Collectors 类提供了一个“groupingBy”，允许您对流执行“group by”操作（类似于数据库中的 GROUP BY）。假设您的对象列表是“对象”类型，以下代码应该可以工作：

Map<String, Integer> valueByCategory = myObjects.stream().collect(Collectors.groupingBy(MyObjects::getCategory, Collectors.summingInt(MyObjects::getValue)));

代码基本上按每个类别对流进行分组，并在每个组上运行一个收集器，汇总每个流元素的 getValue() 的返回值。 见https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html

Answer 2

使用Collectors 类的静态导入：

list.stream().collect(groupingBy(Class::getCategory, summingInt(Class::getValue)));

您将获得一张地图Map<String, Integer>。 Class 必须有 getValue 和 getCategory 方法来编写方法引用，比如

public class Class {
    private String category;
    private int value;

    public String getCategory() { return category; }
    public int getValue() { return value; }
}

Answer 3

基于reduce的方法：

List<Obj> values = list.stream().collect(
        Collectors.groupingBy(Obj::getCategory, Collectors.reducing((a, b) -> new Obj(a.getValue() + b.getValue(), a.getCategory())))
).values().stream().map(Optional::get).collect(Collectors.toList());

坏事是次要的stream() 调用从Optional<Obj> 和中间Map<String, Optional<Obj>> 对象重新映射结果。

我可以建议使用排序的替代变体（可读性较差）：

List<Obj> values2 = list.stream()
    .sorted((o1, o2) -> o1.getCategory().compareTo(o2.getCategory()))
    .collect(
        LinkedList<Obj>::new,
        (ll, obj) -> {
            Obj last = null;
            if(!ll.isEmpty()) {
                last = ll.getLast();
            }

            if (last == null || !last.getCategory().equals(obj.getCategory())) {
                ll.add(new Obj(obj.getValue(), obj.getCategory())); //deep copy here
            } else {
                last.setValue(last.getValue() + obj.getValue());
            }
        },
        (list1, list2) -> {
              //for parallel execution do a simple merge join here
              throw new RuntimeException("parallel evaluation not supported"); 
         }
    );

这里我们按类别对Objs 列表进行排序，然后按顺序对其进行处理，压缩来自同一类别的连续对象。

不幸的是，Java 中没有方法可以在不手动保留最后一个元素或元素列表的情况下执行此操作（另请参阅 Collect successive pairs from a stream）

可以在此处检查两个 sn-ps 的工作示例：https://ideone.com/p3bKV8