Java 检查条件并检索流中单次传递的数据

我有一些数据：

    List<String> constData = new ArrayList<>();
    constData.add("data10115");
    constData.add("data8134");
    constData.add("data8933");
    constData.add("data8206");

    String strJSON = "[{\"type1\":\"data8933,data10115\",\"type2\":\"data8134,data8135,data9931\"},{\"type1\":\"data8204,data10115\",\"type2\":\"data8773,data8206,data9931\"}]";

    Gson gson = new GsonBuilder().create();
    List<Map<String, String>> mappedJSON = gson.fromJson(strJSON, new TypeToken<List<Map<String, String>>>(){}.getType());

---

有没有什么“简单”的方法可以从这个表达式的内部获得交集（我指的是这个部分：anyMatch（Arrays.asList（s.getValue（）.split（“，”）：contains））？

像

CollectionUtils.emptyIfNull（新的ArrayList（Arrays.asList（entry.getValue（）.split（“，”））））这样的表达式有什么意义？！您知道集合从不为空。此外，
Arrays.asList（String[]）
的结果已经是一个
列表
，那么为什么要将它复制到一个新的
ArrayList
？只需使用Arrays.asList（s.getValue（）.split（“，”）

就完成了，只编写了不到一半的代码，并且不需要第三部分库。进一步的

。collect（Collectors.toList（））.forEach（l->result0.add（l））

没有任何意义。如果要对每个元素执行操作，为什么要先收集到

列表中。您可以简单地将
forEach
链接到一个流，但是，因为您只需要在末尾有一个
列表
，所以不要嵌套3
forEach
只调用
将
添加到
列表中
。使用
flatMap
组合一个流，然后使用
.collect（Collectors.toList（））
获取结果列表。如果您想要任何地方的所有匹配列表，则无需预先检查。收集列表并检查它是否为空。这正符合您一次完成的愿望。@Holger如果您谈论lambda的第二种方法，那么在没有预检查的情况下，这是行不通的，因为在某些情况下，结果列表不会为空，但条件不会满足。这就是我来这里的原因。很难识别你的
anyMatch
、
allMatch
和另一个
anyMatch
组合应该做什么。我只是相信你的话，检查应该确定是否有交叉路口，而另一个代码应该收集所有交叉路口。您描述的逻辑意味着“存在交叉点”和“交叉点列表不为空”是可互换的条件。如果不是这样，说明也不完整，或者实现被破坏。但是你没有提到这样的问题，所以你的描述在任何情况下都是不完整的。
    System.out.println(
            mappedJSON.stream()
                .anyMatch(f -> f.entrySet().stream()
                        .allMatch(
                                e -> constData.stream()
                                        .anyMatch(CollectionUtils.emptyIfNull(new ArrayList<>(Arrays.asList(e.getValue().split(","))))::contains)
                        ))
    );

   Set<String> result1 = new HashSet<>();
    for(Map<String, String> mapdata : mappedJSON) {
        Map<String, List<String>> mapNode = new HashedMap<>();
        for (Map.Entry<String, String> entry : mapdata.entrySet()) {
            List<String> listNode = new ArrayList<>();
            constData.stream()
                    .filter(CollectionUtils.emptyIfNull(new ArrayList<>(Arrays.asList(entry.getValue().split(","))))::contains)
                    .collect(Collectors.toList()).forEach(l -> listNode.add(l));
            if(listNode.size() > 0) {
                mapNode.putIfAbsent(entry.getKey(), listNode);
            }
        }
        if(mapNode.entrySet().size() == mapdata.entrySet().size()) {
            result1.addAll(mapNode.entrySet().stream().map(x -> x.getValue()).flatMap(List::stream).collect(Collectors.toList()));
        }
    }
    System.out.println(result1);

    if(
            mappedJSON.stream()
                .anyMatch(f -> f.entrySet().stream()
                        .allMatch(
                                e -> constData.stream()
                                        .anyMatch(CollectionUtils.emptyIfNull(new ArrayList<>(Arrays.asList(e.getValue().split(","))))::contains)
                        ))
    ) {

            List<String> result0 = new ArrayList<>();
            mappedJSON.stream()
                    .forEach(
                            m -> m.entrySet().stream()
                                    .forEach(
                                            s -> constData.stream()
                                                    .filter(CollectionUtils.emptyIfNull(new ArrayList<>(Arrays.asList(s.getValue().split(","))))::contains)
                                                    .collect(Collectors.toList()).forEach(l -> result0.add(l))
                                    )
                    );
            System.out.println(result0);
    }

   mappedJSON.stream().anyMatch(f -> f.entrySet().stream().allMatch(e -> constData.stream().anyMatch(Arrays.asList(s.getValue().split(","))::contains)))