Question

我有应该检查的日志事件列表，它们与应该的相同。有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);

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

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

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

1 个答案: