Java ArrayList - 我如何判断两个列表是否相等，顺序无关紧要？

Question

我有两个ArrayLists 类型为Answer（自制类）。

我想比较这两个列表，看看它们是否包含相同的内容，但顺序无关紧要。

例子：

//These should be equal.
ArrayList<String> listA = {"a", "b", "c"}
ArrayList<String> listB = {"b", "c", "a"}

List.equals 声明如果两个列表包含相同的大小、内容和元素顺序，则它们是相等的。我想要同样的东西，但顺序无关紧要。

有没有简单的方法来做到这一点？还是我需要做一个嵌套的 for 循环，并手动检查两个列表的每个索引？

注意：我无法将它们从 ArrayList 更改为另一种类型的列表，它们需要保持不变。

Answer 1

任何列表的最简单方法可能是：

listA.containsAll(listB) && listB.containsAll(listA)

Answer 2

您可以使用Collections.sort() 对两个列表进行排序，然后使用equals 方法。一个稍微好一点的解决方案是在排序之前首先检查它们的长度是否相同，如果不是，则它们不相等，然后排序，然后使用等于。例如，如果您有两个字符串列表，则类似于：

public  boolean equalLists(List<String> one, List<String> two){     
    if (one == null && two == null){
        return true;
    }

    if((one == null && two != null) 
      || one != null && two == null
      || one.size() != two.size()){
        return false;
    }

    //to avoid messing the order of the lists we will use a copy
    //as noted in comments by A. R. S.
    one = new ArrayList<String>(one); 
    two = new ArrayList<String>(two);   

    Collections.sort(one);
    Collections.sort(two);      
    return one.equals(two);
}

Answer 3

Apache Commons 集合再次拯救：

List<String> listA = Arrays.asList("a", "b", "b", "c");
List<String> listB = Arrays.asList("b", "c", "a", "b");
System.out.println(CollectionUtils.isEqualCollection(listA, listB)); // true

 

List<String> listC = Arrays.asList("a", "b", "c");
List<String> listD = Arrays.asList("a", "b", "c", "c");
System.out.println(CollectionUtils.isEqualCollection(listC, listD)); // false

文档：

org.apache.commons.collections4.CollectionUtils

public static boolean isEqualCollection(java.util.Collection a,
                                        java.util.Collection b)

如果给定的 Collections 包含完全相同的内容，则返回 true 具有完全相同基数的元素。

也就是说，如果 a 中 e 的基数等于 b 中 e 的基数，对于每个 a 或 b 中的元素 e。

参数：

• a - 第一个集合，不能是null
• b - 第二个 收藏，不得为null

返回： true 如果集合包含 具有相同基数的相同元素。

Answer 4

// helper class, so we don't have to do a whole lot of autoboxing
private static class Count {
    public int count = 0;
}

public boolean haveSameElements(final List<String> list1, final List<String> list2) {
    // (list1, list1) is always true
    if (list1 == list2) return true;

    // If either list is null, or the lengths are not equal, they can't possibly match 
    if (list1 == null || list2 == null || list1.size() != list2.size())
        return false;

    // (switch the two checks above if (null, null) should return false)

    Map<String, Count> counts = new HashMap<>();

    // Count the items in list1
    for (String item : list1) {
        if (!counts.containsKey(item)) counts.put(item, new Count());
        counts.get(item).count += 1;
    }

    // Subtract the count of items in list2
    for (String item : list2) {
        // If the map doesn't contain the item here, then this item wasn't in list1
        if (!counts.containsKey(item)) return false;
        counts.get(item).count -= 1;
    }

    // If any count is nonzero at this point, then the two lists don't match
    for (Map.Entry<String, Count> entry : counts.entrySet()) {
        if (entry.getValue().count != 0) return false;
    }

    return true;
}

Answer 5

我会说这些答案漏掉了一个窍门。

Bloch 在他的基本、精彩、简洁的Effective Java 中说，在第 47 项中，标题为“了解并使用库”，“总而言之，不要重新发明轮子”。他给出了几个非常明确的理由。

这里有一些答案建议来自 Apache Commons Collections 库中 CollectionUtils 的方法，但没有发现 the most beautiful, elegant way of answering this question：

Collection<Object> culprits = CollectionUtils.disjunction( list1, list2 );
if( ! culprits.isEmpty() ){
  // ... do something with the culprits, i.e. elements which are not common

}

罪魁祸首：即Lists 不共同的元素。使用CollectionUtils.intersection( list1, culprits ) 和CollectionUtils.intersection( list2, culprits ) 来确定哪些罪魁祸首属于list1 和哪些属于list2 相对简单。
然而，在 { "a", "a", "b" } disjunction with { "a", "b", "b" } 等情况下，它往往会分崩离析……除非这不是软件，但与所需任务的微妙性/模糊性的本质有关。

您总是可以检查source code (l. 287) 来完成这样的任务，由 Apache 工程师制作。使用他们的代码的一个好处是它已经过彻底的尝试和测试，许多边缘案例和陷阱都可以预见和处理。如果需要，您可以根据需要复制和调整此代码。

---

NB 一开始我很失望，因为没有一个 CollectionUtils 方法提供重载版本，让您可以强加自己的 Comparator（因此您可以重新定义 equals 以满足您的目的）。

但是从 collections4 4.0 开始，有一个新类，Equator，它“确定 T 类型对象之间的相等性”。在检查 collections4 CollectionUtils.java 的源代码时，他们似乎将其与某些方法一起使用，但据我所知，这不适用于文件顶部的方法，使用 CardinalityHelper 类。 .. 其中包括disjunction 和intersection。

我推测 Apache 的人还没有解决这个问题，因为它很重要：您必须创建类似“AbstractEquatingCollection”类的东西，而不是使用其元素固有的 equals 和 @ 987654340@ 方法将不得不使用Equator 的所有基本方法，例如add、contains 等。注意实际上当您查看源代码时，AbstractCollection 并没有实现@987654345 @，也不是它的抽象子类如AbstractSet...你必须等到HashSet和ArrayList等具体类在实现add之前。很头疼。

我想，与此同时，请注意这个空间。显而易见的临时解决方案是将所有元素包装在一个定制的包装器类中，该包装器类使用 equals 和 hashCode 来实现您想要的那种平等……然后操纵这些包装器对象的 Collections。

Answer 6

如果项目的基数无关紧要（意思是：重复的元素被视为一个），那么有一种方法可以做到这一点而不必排序：

boolean result = new HashSet<>(listA).equals(new HashSet<>(listB));

这将从每个List 中创建一个Set，然后使用HashSet 的equals 方法（当然）忽略排序。

如果基数很重要，那么您必须限制自己使用List 提供的设施； @jschoen 的回答在这种情况下会更合适。

Answer 7

将列表转换为 Guava 的 Multiset 效果很好。无论它们的顺序如何，都会对它们进行比较，并且还会考虑重复元素。

static <T> boolean equalsIgnoreOrder(List<T> a, List<T> b) {
    return ImmutableMultiset.copyOf(a).equals(ImmutableMultiset.copyOf(b));
}

assert equalsIgnoreOrder(ImmutableList.of(3, 1, 2), ImmutableList.of(2, 1, 3));
assert !equalsIgnoreOrder(ImmutableList.of(1), ImmutableList.of(1, 1));

Answer 8

这是基于@cHao 解决方案。我包括了几个修复和性能改进。它的运行速度大约是 equals-ordered-copy 解决方案的两倍。适用于任何集合类型。空集合和 null 被视为相等。利用你的优势;）

/**
 * Returns if both {@link Collection Collections} contains the same elements, in the same quantities, regardless of order and collection type.
 * <p>
 * Empty collections and {@code null} are regarded as equal.
 */
public static <T> boolean haveSameElements(Collection<T> col1, Collection<T> col2) {
    if (col1 == col2)
        return true;

    // If either list is null, return whether the other is empty
    if (col1 == null)
        return col2.isEmpty();
    if (col2 == null)
        return col1.isEmpty();

    // If lengths are not equal, they can't possibly match
    if (col1.size() != col2.size())
        return false;

    // Helper class, so we don't have to do a whole lot of autoboxing
    class Count
    {
        // Initialize as 1, as we would increment it anyway
        public int count = 1;
    }

    final Map<T, Count> counts = new HashMap<>();

    // Count the items in col1
    for (final T item : col1) {
        final Count count = counts.get(item);
        if (count != null)
            count.count++;
        else
            // If the map doesn't contain the item, put a new count
            counts.put(item, new Count());
    }

    // Subtract the count of items in col2
    for (final T item : col2) {
        final Count count = counts.get(item);
        // If the map doesn't contain the item, or the count is already reduced to 0, the lists are unequal 
        if (count == null || count.count == 0)
            return false;
        count.count--;
    }

    // At this point, both collections are equal.
    // Both have the same length, and for any counter to be unequal to zero, there would have to be an element in col2 which is not in col1, but this is checked in the second loop, as @holger pointed out.
    return true;
}

Answer 9

想一想，在没有计算机或编程语言的情况下，您自己将如何做到这一点。我给你两个元素列表，你必须告诉我它们是否包含相同的元素。你会怎么做？

如上所述，一种方法是对列表进行排序，然后逐个元素地查看它们是否相等（List.equals 就是这样做的）。这意味着您要么被允许修改列表，要么被允许复制它们 - 在不知道分配的情况下，我不知道是否允许其中一个/两个。

另一种方法是遍历每个列表，计算每个元素出现的次数。如果两个列表最后的计数相同，则它们具有相同的元素。其代码是将每个列表转换为elem -> (# of times the elem appears in the list) 的映射，然后在两个映射上调用equals。如果映射是HashMap，则每个转换都是 O(N) 操作，比较也是如此。这将在时间方面为您提供一个非常有效的算法，但会消耗一些额外的内存。

Answer 10

我遇到了同样的问题并想出了一个不同的解决方案。当涉及重复时，这也适用：

public static boolean equalsWithoutOrder(List<?> fst, List<?> snd){
  if(fst != null && snd != null){
    if(fst.size() == snd.size()){
      // create copied lists so the original list is not modified
      List<?> cfst = new ArrayList<Object>(fst);
      List<?> csnd = new ArrayList<Object>(snd);

      Iterator<?> ifst = cfst.iterator();
      boolean foundEqualObject;
      while( ifst.hasNext() ){
        Iterator<?> isnd = csnd.iterator();
        foundEqualObject = false;
        while( isnd.hasNext() ){
          if( ifst.next().equals(isnd.next()) ){
            ifst.remove();
            isnd.remove();
            foundEqualObject = true;
            break;
          }
        }

        if( !foundEqualObject ){
          // fail early
          break;
        }
      }
      if(cfst.isEmpty()){ //both temporary lists have the same size
        return true;
      }
    }
  }else if( fst == null && snd == null ){
    return true;
  }
  return false;
}

与其他一些解决方案相比的优势：

• 小于 O(N²) 复杂度（尽管与此处其他答案中的解决方案相比，我尚未测试它的实际性能）；
• 提前退出；
• 检查是否为空；
• 即使涉及重复也有效：如果您有一个数组[1,2,3,3] 和另一个数组[1,2,2,3]，这里的大多数解决方案都会告诉您在不考虑顺序时它们是相同的。该解决方案通过从临时列表中删除相等的元素来避免这种情况；
• 使用语义相等 (equals) 而不是引用相等 (==)；
• 不对元素进行排序，因此不需要对它们进行排序（按implement Comparable），此解决方案也能正常工作。

Answer 11

如果您不希望对集合进行排序并且您需要 ["A" "B" "C"] 不等于 ["B" "B" "A" "C"] 的结果，

l1.containsAll(l2)&&l2.containsAll(l1)

还不够，你可能还需要检查尺寸：

    List<String> l1 =Arrays.asList("A","A","B","C");
    List<String> l2 =Arrays.asList("A","B","C");
    List<String> l3 =Arrays.asList("A","B","C");

    System.out.println(l1.containsAll(l2)&&l2.containsAll(l1));//cautions, this will be true
    System.out.println(isListEqualsWithoutOrder(l1,l2));//false as expected

    System.out.println(l3.containsAll(l2)&&l2.containsAll(l3));//true as expected
    System.out.println(isListEqualsWithoutOrder(l2,l3));//true as expected


    public static boolean isListEqualsWithoutOrder(List<String> l1, List<String> l2) {
        return l1.size()==l2.size() && l1.containsAll(l2)&&l2.containsAll(l1);
}

Answer 12

利用 CollectionUtils 减法的解决方案：

import static org.apache.commons.collections15.CollectionUtils.subtract;

public class CollectionUtils {
  static public <T> boolean equals(Collection<? extends T> a, Collection<? extends T> b) {
    if (a == null && b == null)
      return true;
    if (a == null || b == null || a.size() != b.size())
      return false;
    return subtract(a, b).size() == 0 && subtract(a, b).size() == 0;
  }
}

Answer 13

如果您关心顺序，那么只需使用 equals 方法：

list1.equals(list2)

如果您不关心订单，请使用此

Collections.sort(list1);
Collections.sort(list2);      
list1.equals(list2)

Answer 14

单行法:)

1. 集合的项目没有实现接口 Comparable

    static boolean isEqualCollection(Collection<?> a, Collection<?> b) {
        return a == b || (a != null && b != null && a.size() == b.size()
            && a.stream().collect(Collectors.toMap(Function.identity(), s -> 1L, Long::sum)).equals(b.stream().collect(Collectors.toMap(Function.identity(), s -> 1L, Long::sum))));
    }
   

2. 集合的项目实现接口 Comparable

    static <T extends Comparable<? super T>> boolean  isEqualCollection2(Collection<T> a, Collection<T> b) {
      return a == b || (a != null && b != null && a.size() == b.size() && a.stream().sorted().collect(Collectors.toList()).equals(b.stream().sorted().collect(Collectors.toList())));
    }
   

3. 通过https://github.com/retrostreams/android-retrostreams支持Android5 & Android6

   static boolean isEqualCollection(Collection<?> a, Collection<?> b) {
    return a == b || (a != null && b != null && a.size() == b.size()
            && StreamSupport.stream(a).collect(Collectors.toMap(Function.identity(), s->1L, Longs::sum)).equals(StreamSupport.stream(b).collect(Collectors.toMap(Function.identity(), s->1L, Longs::sum))));
   }
   

////测试用例

    boolean isEquals1 = isEqualCollection(null, null); //true
    boolean isEquals2 = isEqualCollection(null, Arrays.asList("1", "2")); //false
    boolean isEquals3 = isEqualCollection(Arrays.asList("1", "2"), null); //false
    boolean isEquals4 = isEqualCollection(Arrays.asList("1", "2", "2"), Arrays.asList("1", "1", "2")); //false
    boolean isEquals5 = isEqualCollection(Arrays.asList("1", "2"), Arrays.asList("2", "1")); //true
    boolean isEquals6 = isEqualCollection(Arrays.asList("1", 2.0), Arrays.asList(2.0, "1")); //true
    boolean isEquals7 = isEqualCollection(Arrays.asList("1", 2.0, 100L), Arrays.asList(2.0, 100L, "1")); //true
    boolean isEquals8 = isEqualCollection(Arrays.asList("1", null, 2.0, 100L), Arrays.asList(2.0, null, 100L, "1")); //true

Answer 15

两全其美[@DiddiZ，@Chalkos]：这个主要基于@Chalkos 方法，但修复了一个错误（ifst.next()），并改进了初始检查（取自@DiddiZ）以及删除需要复制第一个集合（只是从第二个集合的副本中删除项目）。

不需要散列函数或排序，并启用不等式的早期存在，这是迄今为止最有效的实现。那是除非你有一个数千或更多的集合长度，以及一个非常简单的散列函数。

public static <T> boolean isCollectionMatch(Collection<T> one, Collection<T> two) {
    if (one == two)
        return true;

    // If either list is null, return whether the other is empty
    if (one == null)
        return two.isEmpty();
    if (two == null)
        return one.isEmpty();

    // If lengths are not equal, they can't possibly match
    if (one.size() != two.size())
        return false;

    // copy the second list, so it can be modified
    final List<T> ctwo = new ArrayList<>(two);

    for (T itm : one) {
        Iterator<T> it = ctwo.iterator();
        boolean gotEq = false;
        while (it.hasNext()) {
            if (itm.equals(it.next())) {
                it.remove();
                gotEq = true;
                break;
            }
        }
        if (!gotEq) return false;
    }
    // All elements in one were found in two, and they're the same size.
    return true;
}

Answer 16

这是检查可以包含空值的数组列表是否相等的另一种方法：

List listA = Arrays.asList(null, "b", "c");
List listB = Arrays.asList("b", "c", null);

System.out.println(checkEquality(listA, listB)); // will return TRUE


private List<String> getSortedArrayList(List<String> arrayList)
{
    String[] array = arrayList.toArray(new String[arrayList.size()]);

    Arrays.sort(array, new Comparator<String>()
    {
        @Override
        public int compare(String o1, String o2)
        {
            if (o1 == null && o2 == null)
            {
                return 0;
            }
            if (o1 == null)
            {
                return 1;
            }
            if (o2 == null)
            {
                return -1;
            }
            return o1.compareTo(o2);
        }
    });

    return new ArrayList(Arrays.asList(array));
}

private Boolean checkEquality(List<String> listA, List<String> listB)
{
    listA = getSortedArrayList(listA);
    listB = getSortedArrayList(listB);

    String[] arrayA = listA.toArray(new String[listA.size()]);
    String[] arrayB = listB.toArray(new String[listB.size()]);

    return Arrays.deepEquals(arrayA, arrayB);
}

Answer 17

我的解决方案。它不是很酷，但效果很好。

public static boolean isEqualCollection(List<?> a, List<?> b) {

    if (a == null || b == null) {
        throw new NullPointerException("The list a and b must be not null.");
    }

    if (a.size() != b.size()) {
        return false;
    }

    List<?> bCopy = new ArrayList<Object>(b);

    for (int i = 0; i < a.size(); i++) {

        for (int j = 0; j < bCopy.size(); j++) {
            if (a.get(i).equals(bCopy.get(j))) {
                bCopy.remove(j);
                break;
            }
        }
    }

    return bCopy.isEmpty();
}

Answer 18

在这种情况下，列表 {"a", "b"} 和 {"b","a"} 是相等的。并且 {"a", "b"} 和 {"b","a","c"} 不相等。如果您使用复杂对象列表，请记住重写 equals 方法，因为 containsAll 在内部使用它。

if (oneList.size() == secondList.size() && oneList.containsAll(secondList)){
        areEqual = true;
}