lambda - 提取属性模式，使用 java lambda 合并并构建列表

Question

我不是 Java Lambda 方面的专家，所以我需要您的帮助。

如何提取以下列表:

[
    {
      "code": 1,
      "nestedList": [{
        "value": "A",
        "count": 1
      }]
    },
    {
      "code": 2,
      "nestedList": [{
        "value": "A",
        "count": 1
      }]
    },
    {
      "code": 3,
      "nestedList": [{
        "value": "A",
        "count": 1
      }]
    },
    {
      "code": 4,
      "nestedList": [{
        "value": "B",
        "count": 1
      }]
    },
    {
      "code": 5,
      "nestedList": [{
        "value": "B",
        "count": 1
      }]
]

至以下一个:

[
  {
    "value": "A",
    "count": 3
  },
  {
    "value": "B",
    "count": 2
  }
]

我尝试了groupingBy、filter等操作，但没有任何效果......

因为我使用以下代码:

public class MainObject {
    List<NestedObject> nestedList;
    //getters and setters
}

public class NestedObject {
    private String value;
    private Integer count;
    //getters and setters
}

List<MainObject> mainObjectList = new ArrayList<>();
        List<NestedObject> nestedObjects = new ArrayList<>();
        NestedObject nestedObject = new NestedObject();
        nestedObject.setValue("A");
        nestedObject.setCount(3);
        nestedObjects.add(nestedObject);
        MainObject mainObject = new MainObject();
        mainObject.setNestedList(nestedObjects);
        mainObjectList.add(mainObject);

        List<NestedObject> nestedList2 = new ArrayList<>();
        NestedObject nestedObject2 = new NestedObject();
        nestedObject2.setValue("A");
        nestedObject2.setCount(2);
        nestedList2.add(nestedObject2);
        MainObject mainObject2 = new MainObject();
        mainObject2.setNestedList(nestedList2);
        mainObjectList.add(mainObject2);

        List<NestedObject> nestedList3 = new ArrayList<>();
        NestedObject nestedObject3 = new NestedObject();
        nestedObject3.setValue("B");
        nestedObject3.setCount(8);
        nestedList3.add(nestedObject3);
        MainObject mainObject3 = new MainObject();
        mainObject3.setNestedList(nestedList3);
        mainObjectList.add(mainObject3);

        List<NestedObject> nestedList4 = new ArrayList<>();
        NestedObject nestedObject4 = new NestedObject();
        nestedObject4.setValue("B");
        nestedObject4.setCount(2);
        nestedList4.add(nestedObject4);
        MainObject mainObject4 = new MainObject();
        mainObject4.setNestedList(nestedList4);
        mainObjectList.add(mainObject4);

        System.out.println(mainObjectList.size());

        List<String> listInteger =
                mainObjectList.stream()
                .map(mainObject -> mainObject.getNestedList())
                .flatMap(List::stream)
                .map(NestedObject::getValue)
                .collect(NestedObject::getValue);

我试图提取值，然后使用另一个foreach获取计数。

我搜索了类似 underscore.js 的内容。但我真的不知道....

Summarize array values, underscore

Answer 1

从预期结果来看，不清楚是否要添加分组后同一存储桶中所有对象的 count 属性，还是仅添加分组后每个存储桶中元素的计数。

因此，我将提供几种解决方案，您可以选择您想要的解决方案。

如果您想按值分组，则对同一存储桶中所有对象的count属性求和:

Map<String, Integer> resultSet = mainObjectList.stream()
                .map(MainObject::getNestedList)
                .flatMap(List::stream)
                .collect(Collectors.groupingBy(NestedObject::getValue,
                        Collectors.summingInt(NestedObject::getCount)));

或者如果您想将结果收集回列表中累积的 NestedObject 类型:

List<NestedObject> resulSet = mainObjectList.stream()
                .map(MainObject::getNestedList)
                .flatMap(List::stream)
                .collect(Collectors.groupingBy(NestedObject::getValue,
                        Collectors.summingInt(NestedObject::getCount)))
                .entrySet()
                .stream()
                .map(e -> {
                    NestedObject obj = new NestedObject();
                    obj.setCount(e.getValue());
                    obj.setValue(e.getKey());
                    return obj;
                }).collect(Collectors.toList());

如果您想按值分组，请计算同一存储桶中的对象数量:

Map<String, Long> resultSet = mainObjectList.stream()
            .map(MainObject::getNestedList)
            .flatMap(List::stream)
            .collect(Collectors.groupingBy(NestedObject::getValue,
                    Collectors.counting()));

或者如果您想将结果收集回列表中累积的 NestedObject 类型:

List<NestedObject> resultSet = mainObjectList.stream()
                .map(MainObject::getNestedList)
                .flatMap(List::stream)
                .collect(Collectors.groupingBy(NestedObject::getValue,
                        Collectors.summingInt(e -> 1)))
                .entrySet()
                .stream()
                .map(e -> {
                    NestedObject obj = new NestedObject();
                    obj.setCount(e.getValue());
                    obj.setValue(e.getKey());
                    return obj;
                }).collect(Collectors.toList());