断言 List<List<String>> 包含没有顺序的 List<String>

Question

我有一个List<List<String>>，其中包含如下示例数据：

("T1#R1", "T1#R1", "T1#R3", "T1#R4")
("T1#R1", "T1#R1", "T1#R3", "T1#R5")
("T1#R1", "T1#R1", "T1#R6", "T1#R4")
("T1#R1", "T1#R1", "T1#R6", "T1#R5")

我需要断言，List<String> 存在于上述示例中，但未考虑顺序。

例如，以下列表 ("T1#R1", "T1#R1", "T1#R4", "T1#R3") 应被视为存在于 List<List<String>> 中，因为它将包含与第一个列表相同的项目，但顺序不同。

另一方面，("T1#R1", "T1#R3", "T1#R4", "T1#R3") 不应被视为存在于列表中，因为它具有相同的项目，但计数不同。

我知道我可以以编程方式执行此操作，但是如果有 Matcher 可以提供帮助，我会徘徊。

我见过这样的断言：

assertThat(myList, containsInAnyOrder(anotherList.toArray())

但这只会将一个列表与另一个列表进行比较，而不是列表列表中的列表。

PS：我用的是Java6，hamcrest-core-1.3，testng-5.14.1

Answer 1

我不知道有任何匹配器可以做你想做的事，所以恐怕你必须对其进行编程。

我只需对目标列表进行排序，然后迭代子列表直到找到匹配项：

List<String> target = new ArrayList<>(anotherList);
target.sort();

boolean result = myList.stream()
    .anyMatch(sublist -> equalsInAnyOrder(sublist, target));

equalsInAnyOrder 方法如下：

public <T> boolean equalsInAnyOrder(List<T> sublist, List<T> target) {

    List<String> copy = new ArrayList<>(sublist);
    copy.sort();

    return copy.equals(target);
}

这会对每个子列表进行排序，并将其与目标排序列表进行比较，因此它不是性能方面的，但至少它是简单而简洁的代码。

---

根据 OP 针对 Java 6 的需要进行编辑：

逻辑与 Java 8 版本中的完全相同。首先对目标列表进行排序，然后比较每个子列表，直到找到匹配项：

List<String> target = new ArrayList<>(anotherList);
Collections.sort(target);

stream() 和 anyMatch 现在变成了 while 循环：

boolean match = false;
Iterator<List<String>> it = myList.iterator();
while (it.hasNext() && !match) {
    List<String> sublist = it.next();
    match = equalsInAnyOrder(sublist, target);
}

现在方法 equalsInAnyOrder 看起来像这样：

public <T> boolean equalsInAnyOrder(List<T> sublist, List<T> target) {

    List<String> copy = new ArrayList<>(sublist);
    Collections.sort(copy);

    return copy.equals(target);
}

Answer 2

我没有得到单行解决方案，但我的测试通过了。

我遍历列表列表，将每个列表包装到一个映射（条目是键，计算值）以及要检查的列表。现在我可以检查是否相等：

public void listOfLists() throws Exception {
    List<List<String>> myList = Arrays.asList(
        Arrays.asList("T1#R1", "T1#R1", "T1#R3", "T1#R4"),
        Arrays.asList("T1#R1", "T1#R1", "T1#R3", "T1#R5"),
        Arrays.asList("T1#R1", "T1#R1", "T1#R6", "T1#R4"),
        Arrays.asList("T1#R1", "T1#R1", "T1#R6", "T1#R5"));
    List<String> easy = Arrays.asList("T1#R1", "T1#R1", "T1#R4", "T1#R3");
    List<String> duplicate = Arrays.asList("T1#R1", "T1#R5", "T1#R1", "T1#R6");
    List<String> noMatch = Arrays.asList("T1#R1", "T1#R5", "T1#R6");

    Map<String, Integer> easyCount = countEntries(easy);
    Map<String, Integer> duplicateCount = countEntries(duplicate);
    Map<String, Integer> noCount = countEntries(noMatch);

    for (List<String> l : myList) {
        Map<String, Integer> countedEntries = countEntries(l);
        if (countedEntries.equals(easyCount)) {
            System.out.println("easy matches");
        }
        if (countedEntries.equals(duplicateCount)) {
            System.out.println("duplicate matches");
        }
        if (countedEntries.equals(noCount)) {
            System.out.println("Damn!");
        }
    }
}

private Map<String, Integer> countEntries(List<String> original) {
    return original.stream()
        .collect(Collectors.toMap(Function.identity(), s -> 1, Integer::sum));
}

打印出来

easy matches
duplicate matches

Answer 3

我不知道有任何 Matcher 这样做，你是否关心重复？ （你的字符串中会有重复的值吗？）

我会去做这样的事情：

private boolean containsInAnyOrder(List<List<String>> container, List<String> list)
{
  for (List<String> list1 : container)
  {
     if(list.size()==list1.size())
     {
        if(list1.containsAll(list))
        {
           return true;
        }
     }
  }
  return false;
}

这只有在你不关心重复元素并且存在计数时才有效。

("T1#R1", "T1#R1", "T1#R1", "T1#R2")
("T1#R1", "T1#R2", "T1#R2", "T1#R1")

例如，将返回 true。你会重复吗？ （对于 Set 解决方案，同样的原因，它不会起作用）

如果出现重复，您需要计算每个项目：

private boolean containsInAnyOrder(List<List<String>> container, List<String> list)
{
  for (List<String> list1 : container)
  {
     if(list.size()==list1.size())
     {
        boolean found = true;
        for(String string : list)
        {
           if (list.stream().filter(pS -> pS.equals(string)).count() != list1.stream().filter(pS -> pS.equals(string)).count())
           {
              found = false;
           }
        }
        if(found)
        {
           return true;
        }
     }
  }
  return false;
}

注意它没有优化，内部for循环可能会在不匹配的情况下停止。