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

Question

我有我应该检查的日志事件列表，它们应该是一样的。有事件对象的结构:

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);

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

Answer 1

你的问题是你只是检查每个 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