Java 8 如何迭代嵌套映射的数组，然后使用stream（）收集特定字段的值。map（）；

我希望从值为key=“value”的链接HashMap对象数组中收集值

在下面的代码中，我使用stream.map（）手动迭代了

arrayOfObjects

的每个对象，然后获得“value”字段的值。然后，

arrayOfObjects

的每个对象都有一个子对象，它也是一个对象数组，我还分别使用stream.map（）收集了“value”字段的值

//对象1
HashMap outerObject1=新LinkedHashMap（）；
outerObject1.put（“值”、“值1”）；
//对象1的子对象1
HashMap inner1Child1=新的LinkedHashMap（）；
内部1 child1.put（“值”、“值1 child1”）；
//对象1的子对象2
HashMap inner1Child2=新的LinkedHashMap（）；
内部1 child2.put（“值”、“值1 child2”）；
//对象1的子对象3
HashMap inner1Child3=新的LinkedHashMap（）；
inner1Child3.put（“值”、“重复”）；
List childrenOfOuterObject1=新建ArrayList(
asList（inner1Child1、inner1Child2、inner1Child3）；
outerObject1.put（“CHILD”，childrenOfOuterObject1）；
//对象2
HashMap outerObject2=新LinkedHashMap（）；
outerObject2.put（“值”、“值2”）；
//对象2的子对象1
HashMap inner2Child1=新LinkedHashMap（）；
inner2Child1.put（“VALUE”、“val2Child1”）；
//对象2的子对象2
HashMap inner2Child2=新LinkedHashMap（）；
inner2Child2.put（“VALUE”、“val2Child2”）；
//对象2的子对象3
HashMap inner2Child3=新LinkedHashMap（）；
inner2Child3.put（“值”、“重复”）；
List childrenOfOuterObject2=新建ArrayList(
asList（inner2Child1、inner2Child2、inner2Child3）；
outerObject2.put（“CHILD”，childrenOfOuterObject2）；
List arrayOfObjects=新的ArrayList（Arrays.asList（outerObject1，outerObject2））；
List outerValues=arrayOfObjects.stream（）.map（obj->（String）obj.get（“VALUE”）.collect(
收藏家；
System.out.println（外部值）；
List innerChildren1=（List）outerObject1.get（“CHILD”）；
List innerValues1=innerChildren1.stream（）.map（obj->（String）obj.get（“VALUE”））.collect（Collectors.toList（））；
System.out.println（内部值1）；
List innerChildren2=（List）outerObject2.get（“CHILD”）；
List innerValues2=innerChildren2.stream（）.map（obj->（String）obj.get（“VALUE”））.collect（Collectors.toList（））；
System.out.println（内部值2）；
Set aggregatedValues=newhashset（outerValues）；
aggregatedValues.addAll（内部值1）；
aggregatedValues.addAll（内部值2）；
System.out.println（聚合值）；

我的数据与以下结构相似：

[
    {
        "VALUE": "val1",
        "CHILD": [
            {
                "VALUE": "val1Child1"
            },
            {
                "VALUE": "val1Child2"
            },
            {
                "VALUE": "DUPLICATE"
            }
        ]

    },
    {
        "VALUE": "val2",
        "CHILD": [
            {
                "VALUE": "val2Child1"
            },
            {
                "VALUE": "val2Child2"
            },
            {
                "VALUE": "DUPLICATE"
            }
        ]

    }
]

我希望我的输出数据如下所示，不使用嵌套的循环进行迭代：

[DUPLICATE, val2, val1, val2Child1, val2Child2, val1Child1, val1Child2]

---

首先，像您这样使用复杂类型，

HashMap

where Object是一个列表，这不是一个好的选择，因为我建议使用OOP来解决您的问题，所以创建一个如下类：

public class MyObject {
    private String value;
    private List<MyObject> child;

    public MyObject(String value) {
        this.value = value;
    }

    public MyObject(String value, List<MyObject> child) {
        this.value = value;
        this.child = child;
    }
    // Getters and setters
}

Set<String> result = parents.stream()
        .flatMap(p -> {
            Set<String> values = new HashSet<>();
            values.add(p.getValue());
            values.addAll(p.getChild().stream()
                    .map(MyObject::getValue)
                    .collect(Collectors.toSet()));
            return values.stream();
        }).collect(Collectors.toSet());

---

我最终使用了这个``AtomicReference aggregatedValues2=new AtomicReference（new HashSet（））；arrayOfObjects.forEach（stringObjectHashMap->{String value=（String）stringObjectHashMap.get（“value”）；aggregatedValues2.get（）.add（value）；List children=（List）stringObjectHashMap.get（“CHILD”）；aggregatedValues2.get（）.addAll（children.stream（）.map（Objects->（String）obj.get（“value”））.Collector（Collectors.toList（））；}）；系统输出打印项次（聚合值2）```嗨@YCF_L！谢谢你的回复。OOP是一个很好的解决方案。然而，我们使用的技术是处理JSON数据。我们只使用API从数据库（MongoDB | NoSQL DB）查询数据。它返回具有从HashMap继承的类的对象。数据非常动态，包含不同的字段。例如：Obj1_1有字段“CHILD”，它可以是数组、对象或文字。因此，仅为此创建一个类是不够的，因为它的数据模型是不固定的。@GreenMachineDisposer，我确信您可以使用OOP来反序列化json，如果您继续以这种方式使用Map-inside-Map-inside-Map。。。，休息一下，寻找解决json问题的解决方案first@GreenMachineDisposer看看这个，非常感谢。事实上，我们的模型确实需要反序列化。

Set<String> result = parents.stream()
        .flatMap(p -> {
            Set<String> values = new HashSet<>();
            values.add(p.getValue());
            values.addAll(p.getChild().stream()
                    .map(MyObject::getValue)
                    .collect(Collectors.toSet()));
            return values.stream();
        }).collect(Collectors.toSet());

[DUPLICATE, val2, val1, val2Child1, val2Child2, val1Child1, val1Child2]