Java 比较2个列表<；字符串>；如果它们以任何顺序包含相同的元素[JUnit-Asset]

我想通过使用JUnit创建单元测试来测试是否正确生成了一些字符串列表

我有两个字符串列表（我的代码中有一个列表是private static final，让我们说list1），它们具有不同顺序的相同元素（相同元素可以相乘）：

List<String> list1 = Arrays.asList("a","b","c");
List<String> list2 = Arrays.asList("c","a","b");
assertThat(list1 , containsInAnyOrder(list2));

我不知道如何实现这个

Matcher

我不想使用这种类型的函数，因为它只适用于少量元素：

containsInAnyOrder(T... items)

---

这取决于您是否希望复制

如果没有重复，1个简单选项正在使用

Set

-通过使用和使用

assertEquals（setA，setB），两个集合彼此相等

有更多的“基本”方法（对每个唯一值使用
HashMap
，并比较每个值的重复）来执行此操作，但对于您要检查的内容，这取决于您是否希望有重复

如果没有重复，1个简单选项正在使用
Set
-通过使用和使用
assertEquals（setA，setB），两个集合彼此相等

有更多的“基本”方法（对每个唯一值使用
HashMap
，并比较每个值的重复）来执行此操作，但对于您要检查的内容，我在一个：

测试列表的完整方法：

@Test
public void testAssertList() {

    List<String> actual = Arrays.asList("a", "b", "c");
    List<String> expected = Arrays.asList("a", "b", "c");

    //All passed / true

    //1. Test equal.
    assertThat(actual, is(expected));

    //2. If List has this value?
    assertThat(actual, hasItems("b"));

    //3. Check List Size
    assertThat(actual, hasSize(3));

    assertThat(actual.size(), is(3));

    //4.  List order

    // Ensure Correct order
    assertThat(actual, contains("a", "b", "c"));

    // Can be any order
    assertThat(actual, containsInAnyOrder("c", "b", "a"));

    //5. check empty list
    assertThat(actual, not(IsEmptyCollection.empty()));

    assertThat(new ArrayList<>(), IsEmptyCollection.empty());

}

@测试
公共无效测试列表（）{
列表实际值=数组。asList（“a”、“b”、“c”）；
预期列表=数组。asList（“a”、“b”、“c”）；
//全部通过/正确
//1.测试相等。
（实际的、预期的）资产；
//2.列表是否有此值？
资产（实际，有项目（“b”）；
//3.检查列表大小
资产（实际，hasSize（3））；
断言（actual.size（），为（3））；
//4.列表顺序
//确保秩序正确
（实际的，包含（“a”、“b”、“c”））的资产；
//可以是任何订单
资产（实际，包含任何订单（“c”、“b”、“a”））；
//5.检查空列表
断言（实际的，不是（IsEmptyCollection.empty（））；
断言（newarraylist（），IsEmptyCollection.empty（））；
}

您的测试可能失败，因为
list1
实际上不包含
list2
，而是包含
list2
中的元素。我在一个

测试列表的完整方法：

@Test
public void testAssertList() {

    List<String> actual = Arrays.asList("a", "b", "c");
    List<String> expected = Arrays.asList("a", "b", "c");

    //All passed / true

    //1. Test equal.
    assertThat(actual, is(expected));

    //2. If List has this value?
    assertThat(actual, hasItems("b"));

    //3. Check List Size
    assertThat(actual, hasSize(3));

    assertThat(actual.size(), is(3));

    //4.  List order

    // Ensure Correct order
    assertThat(actual, contains("a", "b", "c"));

    // Can be any order
    assertThat(actual, containsInAnyOrder("c", "b", "a"));

    //5. check empty list
    assertThat(actual, not(IsEmptyCollection.empty()));

    assertThat(new ArrayList<>(), IsEmptyCollection.empty());

}

@测试
公共无效测试列表（）{
列表实际值=数组。asList（“a”、“b”、“c”）；
预期列表=数组。asList（“a”、“b”、“c”）；
//全部通过/正确
//1.测试相等。
（实际的、预期的）资产；
//2.列表是否有此值？
资产（实际，有项目（“b”）；
//3.检查列表大小
资产（实际，hasSize（3））；
断言（actual.size（），为（3））；
//4.列表顺序
//确保秩序正确
（实际的，包含（“a”、“b”、“c”））的资产；
//可以是任何订单
资产（实际，包含任何订单（“c”、“b”、“a”））；
//5.检查空列表
断言（实际的，不是（IsEmptyCollection.empty（））；
断言（newarraylist（），IsEmptyCollection.empty（））；
}

您的测试可能会失败，因为
list1
实际上并不包含
list2
，而是包含
list2
中的元素。您可以先对
列表进行排序，然后比较排序后的
列表

List<String> list1 = Arrays.asList("a","b","c");
List<String> list2 = Arrays.asList("c","a","b",);
Collections.sort(list1);
Collections.sort(list2);
assertEquals( list1, list2 ); // true

list1=Arrays.asList（“a”、“b”、“c”）；
list2=Arrays.asList（“c”、“a”、“b”）；
Collections.sort（列表1）；
Collections.sort（列表2）；
assertEquals（列表1、列表2）；//符合事实的
您可以先对
列表进行排序，然后比较排序后的
列表

List<String> list1 = Arrays.asList("a","b","c");
List<String> list2 = Arrays.asList("c","a","b",);
Collections.sort(list1);
Collections.sort(list2);
assertEquals( list1, list2 ); // true

list1=Arrays.asList（“a”、“b”、“c”）；
list2=Arrays.asList（“c”、“a”、“b”）；
Collections.sort（列表1）；
Collections.sort（列表2）；
assertEquals（列表1、列表2）；//符合事实的
到目前为止，这是最通用的解决方案，没有集合，没有额外的排序

assertThat(list1, containsInAnyOrder(list2.toArray()));

但我仍然想知道如何实现此调用：

containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)

containsInAnyOrder（java.util.Collection到目前为止，这是最通用的解决方案，没有集合，没有额外的排序

assertThat(list1, containsInAnyOrder(list2.toArray()));

但我仍然想知道如何实现此调用：

containsInAnyOrder(java.util.Collection<Matcher<? super T>> itemMatchers)

containsInAnyOrder（java.util.CollectionTry
containsInAnyOrder（isIn（list2））
将不处理重复的条目，因为
containsInAnyOrder
不关心重复的条目不是针对列表中的元素，而是针对匹配器。这意味着，给定多个匹配器，每个元素可以以任何顺序满足任何匹配器。请尝试
containsInAnyOrder（isIn（list2））
将不处理重复项，因为
containsInAnyOrder
不关心重复项。“InAnyOrder”不是针对列表中的元素，而是针对匹配器。这意味着，给定多个匹配器，每个元素可以以任何顺序满足任何匹配器。