通过使用条件的嵌套列表元素将对象与另一个列表匹配来过滤对象

Question

我正在尝试使用 Java8 流过滤和收集具有条件的对象

我有一个实例列表，其中有一个嵌套的元素列表

public class Model {
List<Instance> instances;
}
public class Instance {
private String name;
List<Element> elements;
}
public class Element {
private String partNumber;
}

下面是josn的例子

{
    "instances": [
        {
            "name": "instance1",
            "elements": [
                {
                    "partNumber": "partNumber1"
                },
                {
                    "partNumber": "partNumber2"
                }
            ]
        },
        {
            "name": "instance2",
            "elements": [
                {
                    "partNumber": "partNumber3"
                },
                {
                    "partNumber": "partNumber4"
                }
            ]
        }
    ]
}

和其他响应对象

public class Response {
private List<Domain> domains;
}
public class Domain {
private String name;
private List<Hardware> hardwares;
}
public class Hardware {
private String partNumber;
}

示例 json

{
    "domains": [
        {
            "name": "domain1",
            "hardwares": [
                {
                    "partNumber": "partNumber1"
                }
            ]
        },
        {
            "name": "domain2",
            "hardwares": [
                {
                    "partNumber": "partNumber2"
                },
                {
                    "partNumber": "partNumber3"
                },
                {
                    "partNumber": "partNumber4"
                }
            ]
        },
        {
            "name": "domain3",
            "hardwares": [
                {
                    "partNumber": "partNumber5"
                },
                {
                    "partNumber": "partNumber6"
                }
            ]
        }
    ]
}

我正在尝试通过比较来自域的 Hardwares 是否包含来自请求的每个元素的 partnumber 来流式传输和收集响应对象。这意味着每个Instance 中至少有一个hardware 应该出现在Domains hardwares 中，以便将Domain 视为有效。

对于上述样本数据，

1. domain1 不是有效的域，因为它只包含至少 一个partnumberpartNumber1来自instance1但不包含 至少一个partnumber 来自instance2
2. domain2 是有效的 域，因为它至少包含一个 partnumber partNumber2 来自instance1 并包含至少一个partnumber partNumber3 来自instance2。它可以包含其他部件号，即 好的
3. domain3 不是有效域，因为它不包含 至少一个partnumber 来自instance1 并且不包含 至少一个partnumber 来自instance2

我开始写了

request.getInstances().stream().flatMap(instance -> instance.getElement().stream().filter(element -> response.getDomains().stream().flatMap(domain -> domain.getHardwares.stream().anyMatch(hardware-> element.contains()

但由于我对流的理解有限，我很难完成这项工作

Answer 1

您可能可以在一个流中完成所有操作，但我建议使用两个流。首先，从模型中生成一组零件名称列表；然后，流式传输响应以查找域，以便对于每个实例，该域中的某个部分名称包含在该实例的部分名称集中。

List<Set<String>> parts = model.getInstances().stream()
        .map(i -> i.getElements().stream()
                .map(Element::getPartNumber)
                .collect(Collectors.toSet()))
        .collect(Collectors.toList());

response.getDomains().stream()
        .filter(d -> parts.stream()
                .allMatch(p -> d.getHardwares().stream()
                        .map(Hardware::getPartNumber)
                        .anyMatch(p::contains)))
        .forEach(System.out::println);

关于您的 cmets：现在，如果有一个没有元素的实例，这应该删除所有域，因为 allMatch 将针对该实例失败。如果只是忽略没有元素的实例，您可以在第一个流中添加另一个 filter 以创建 parts 列表（未测试）：

        .filter(i -> ! i.getElements().isEmpty())

或者i.getElements() != null，取决于它的初始化方式。