我有两个类型为Answer的ArrayList（自定义类）。
我想比较这两个列表，以确定它们是否包含相同的内容，但不考虑顺序。
例如：
//These should be equal.
ArrayList<String> listA = {"a", "b", "c"}
ArrayList<String> listB = {"b", "c", "a"}
List.equals声明，如果两个列表包含相同大小、内容和顺序的元素，则它们相等。我想实现相同的功能，但不考虑顺序。
有没有简单的方法可以实现这个功能？还是我需要使用嵌套的for循环，并手动检查两个列表的每个索引?
注意：我不能将它们从ArrayList更改为其他类型的列表，它们必须保持不变。
对于任何列表来说，可能最简单的方法是：
listA.containsAll(listB) && listB.containsAll(listA)
你可以使用Collections.sort()对这两个列表进行排序，然后使用equals方法进行比较。稍微更好的解决方案是在排序之前先检查它们的长度是否相同，如果不同，则它们不相等，然后再排序，最后再使用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);
}
Collections.sort一样），即传递一个副本。 - arshajiione = new ArrayList<String>(one); two = new ArrayList<String>(two); 以避免破坏参数。 - arshajiipublic static <T extends Comparable<? super T>> boolean equalLists (List<T> one, List<T> two)，这样它就是通用的了。 - Marcus Junius Brutusone.equals(two)替换为if(one.get(0) == two.get(0) && one.get(one.size()-1) == two.get(one.size()-1)) return true; else return false;会给出更优化的代码吗？ - Shivang Doshiif(one == null || two == null || one.size() != two.size()) { return false; }，因为您已经检查了one和two是否都为空。 - HugoApache Commons Collections再次拯救了我们：
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)
a - 第一个集合，不能为空b - 第二个集合，不能为空implementation 'org.apache.commons:commons-collections4:4.3' 给我留下了一个错误 Caused by: com.android.builder.dexing.DexArchiveBuilderException: 无法处理 **路径**. - Aliton Oliveira// 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;
}
count变成负数，这也可能在第二个循环中短路，从而简化循环体为if(!counts.containsKey(item) || --counts.get(item).count < 0) return false;。此外，第三个循环可以简化为for(Count c: counts.values()) if(c.count != 0) return false;。 - Holgercounts是否为空”），但我不想掩盖主要观点：使用映射基本上将其转变为O(N+M)问题，并且是您可能获得的最大提升。 - cHaoMap.merge方法。请参见此答案... - Holger我认为这些答案都忽略了一个技巧。
在他的经典著作《Effective Java》中，Bloch在第47条中写道，“知道并使用库”，“简而言之，不要重复造轮子”。他给出了几个非常清晰的原因。
这里有一些答案建议使用Apache Commons Collections库中的CollectionUtils方法，但没有人注意到回答这个问题最美丽、优雅的方式：
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。disjunction with { "a", "b", "b" }的情况下，它往往会崩溃... 但这并不是软件的缺陷，而是所需任务的微妙/模糊本质所固有的。
您可以随时检查源代码 (l.287)以了解此类任务的生成方式，由Apache工程师制作。使用他们的代码的一个好处是，它将经过彻底的尝试和测试，已经预见并处理了许多边缘情况和问题。如果需要，您可以复制和调整此代码。
NB：一开始我很失望，因为CollectionUtils中没有任何一个方法提供重载版本，使您可以强制使用自己的Comparator（以便您可以重新定义equals以适应您的目的）。
但是从collections4 4.0开始，有一个新类Equator，它“确定类型T的对象之间的相等性”。在检查collections4 CollectionUtils.java源代码时，他们似乎正在将其与某些方法一起使用，但据我所知，这不适用于文件顶部使用CardinalityHelper类的方法...其中包括disjunction和intersection。
将列表转换为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));
这是基于@cHao的解决方案。我进行了几个修复和性能改进。这个解决方案大约比等值排序复制的解决方案快两倍。适用于任何集合类型。空集合和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;
}
false。由于两个列表的总大小匹配（这已经在前面检查过），因此在第二个循环之后不可能存在非零值，因为一个键不能存在正值而没有另一个键的负值。 - Holger如果没有计算机或编程语言的帮助，你会怎么做呢？我给你两个元素列表，你需要告诉我它们是否包含相同的元素。你会如何处理呢？
一种方法是按照上面提到的那样，对列表进行排序，然后逐个比较元素以查看它们是否相等（这就是List.equals所做的）。这意味着你可以修改列表或复制它们，而不知道任务的具体情况，我无法确定哪一个/哪些是允许的。
另一种方法是遍历每个列表，计算每个元素出现的次数。如果两个列表在末尾具有相同的计数，则它们具有相同的元素。代码应该将每个列表转换为一个元素 -> (在列表中出现的次数)映射，然后对两个映射调用equals方法。如果映射是HashMap，则每个转换都是O(N)操作，比较也是如此。这将给您一个相当高效的时间算法，但需要额外的内存开销。
我曾经遇到过同样的问题，并想出了一个不同的解决方案。当涉及到重复项时，这个解决方案也可以起作用：
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;
}
[1,2,3,3]和另一个数组[1,2,2,3]，大多数解决方案都会告诉您它们在不考虑顺序的情况下是相同的。此解决方案通过从临时列表中删除相等元素来避免这种情况；equals)而不是引用相等性(==)；实现Comparable进行排序才能使此解决方案正常工作。