时间戳

首页 > 解决方案 > Streams，检查两个对象列表是否具有相同的另一个对象的嵌套列表

java - Streams，检查两个对象列表是否具有相同的另一个对象的嵌套列表

问题描述

我有我应该检查的日志事件列表，它们与应有的相同。Event对象的结构：

public class Event {
    public String type;
    public List<Item> items;

    public Event(String type, List<Item> items) {
        this.type = type;
        this.items = items;
    }
}
public class Item {
    public String id;
    public String value;

    public Item(String id, String value) {
        this.id = id;
        this.value = value;
    }
}

让我们填充“应该”对象，“真实”对象并检查它们是否具有相同的项目

List<Event> should = asList(
                new Event("1000", asList(new Item("server_id", "1"), new Item("user_id", "11"))),
                new Event("1000", asList(new Item("server_id", "1"), new Item("user_id", "11"))));
        List<Event> logged = asList(
                new Event("1000", asList(new Item("server_id", "1"), new Item("user_id", "11"))),
                new Event("1000", asList(new Item("server_id", "1"), new Item("user_id", "11"))));
        boolean logMatch = logged.stream()
                                    .allMatch(e1 ->
                                            should.stream()
                                                      .allMatch(e2 -> e2.items
                                                                        .stream()
                                                                        .allMatch(a2 -> e1.items
                                                                                          .stream()
                                                                                          .anyMatch(a1 -> a1.value.equals(a2.value)))));
        System.out.println(logMatch);

这是真的，但我有一个问题，如果我将“应该”的任何值更改为“11”，我会得到真实的。我该如何解决这个问题或如何使这个比较更简单？

标签： javajava-8java-stream

解决方案

您的问题是您只是在检查每个logged元素是否在should列表中至少有一个元素与它具有相同的value. 您宁愿检查这两个value集合是否等价。

在这种情况下，一个简单的更正可以使用列表比较：

List<String> actualValues =  logged.stream().flatMap(l -> l.items.stream())
        .map(i -> i.value).collect(Collectors.toList());
List<String> shouldValues = should.stream().flatMap(l -> l.items.stream())
        .map(i -> i.value).collect(Collectors.toList());

boolean logMatch = actualValues.equals(shouldValues);

这种比较是严格的，并考虑了顺序。如果您宁愿忽略元素的顺序，您可以收集设置以忽略项目的顺序。

编辑：如果您需要检查多个字段，您可以比较实际事件。以下使用谓词：

List<Item> actualValues =  logged.stream().flatMap(l -> l.items.stream())
        .collect(Collectors.toList());
List<Item> shouldValues = should.stream().flatMap(l -> l.items.stream())
        .collect(Collectors.toList());

BiPredicate<Item, Item> predicate = (item1, item2) -> item1.id.equals(item2.id) 
        && item1.value.equals(item2.value);

boolean res = actualValues.size() == shouldValues.size() //should be same length
        && IntStream.range(0, actualValues.size())
        .filter(i -> !predicate.test(actualValues.get(i), shouldValues.get(i)))
        .count() == 0; //all elements's ID and value must match

推荐阅读