找到两个不同的列表是否包含完全相同的元素的简单方法?

在标准Java库中，找出两个list是否包含完全相同的元素的最简单方法是什么?

这两个list是否为相同实例并不重要，这两个list的类型参数是否不同也不重要。

如。

List list1
List<String> list2;
// ... construct etc


list1.add("A");
list2.add("A");
// the function, given these two lists, should return true

我知道可能有什么东西在盯着我的脸:-)

编辑:为了澄清，我正在寻找完全相同的元素和元素的数量，按顺序。

530026 次浏览
小开

List上的equals方法可以做到这一点，列表是有序的，所以要相等，两个List必须具有相同的元素，且顺序相同。

return list1.equals(list2);
小开 
list1.equals(list2);

如果你的列表包含一个自定义类MyClass，这个类必须覆盖equals函数。

 class MyClass
{
int field=0;
@0verride
public boolean equals(Object other)
{
if(this==other) return true;
if(other==null || !(other instanceof MyClass)) return false;
return this.field== MyClass.class.cast(other).field;
}
}

注意:如果你想在java.util.Set而不是java.util.List上测试equals，那么你的对象必须覆盖hashCode函数。

小开

这取决于您使用的具体List类。抽象类AbstractCollection有一个名为containsAll(Collection)的方法，它接受另一个集合(List是一个集合)，并且:

如果此集合包含指定集合中的所有元素，则返回true。

如果传入一个数组列表你可以调用这个方法来检查它们是否完全相同。

       List foo = new ArrayList();
List bar = new ArrayList();
String str = "foobar";


foo.add(str);
bar.add(str);


foo.containsAll(bar);

使用containsAll()的原因是它遍历第一个列表以查找第二个列表中的匹配项。因此，如果它们的顺序不对，equals()将不会拾取它。

< p >编辑: 我只是想在这里对执行所提供的各种选项的平摊运行时间做一个评论。运行时间重要吗?确定。这是你唯一应该考虑的事情吗?没有。< / p >

从列表中复制每个元素到其他列表的成本需要时间，而且还占用大量内存(有效地使您所使用的内存增加一倍)。

因此，如果JVM中的内存不是问题(通常应该是)，那么您仍然需要考虑将每个元素从两个列表复制到两个TreeSets所花费的时间。记住，它在输入每个元素时对它们进行排序。

我最后的建议?你需要考虑你的数据集，你的数据集中有多少元素，以及你的数据集中每个对象有多大，然后你才能做出好的决定。摆弄它们，每种方式创建一个，看看哪个运行得更快。这是一个很好的练习。

小开
最佳答案

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

list1.equals(list2)

从javadoc:

比较指定对象 这是关于平等的列表。返回true 当且仅当指定的对象为 也是一个列表，两个列表都有相同的值 大小，以及所有对应的对 两个列表中的元素是相等的。 (两个元素e1和e2是相等的if (e1 = =零?e2 = =零: . equals (e2)))。换句话说，是两个 列表被定义为相等，如果它们 在相同中包含相同的元素 秩序。这个定义确保了 equals方法可以正常工作 在不同的实现中

. List接口

如果你想检查与顺序无关，你可以复制所有的元素到set，并在结果集上使用equals:

public static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
return new HashSet<>(list1).equals(new HashSet<>(list2));
}

这种方法的一个局限性是它不仅忽略了顺序，而且还忽略了重复元素的频率。例如，如果list1是["A"， &;B"， &;A"]，而list2是["A"， &;B"]， Set方法会认为它们是相等的。

如果你需要对顺序不敏感，但对重复的频率敏感，你可以:

小开

我在评论里发了一堆东西，我认为它有自己的答案。

正如这里所有人所说，使用equals()取决于顺序。如果你不关心顺序，你有三种选择。

选项1

使用containsAll()。在我看来，这个选项并不理想，因为它提供了最坏情况下的性能O(n²)。

选项2

这种说法有两种变体:

如果你不关心保持列表的顺序…在两个列表中使用Collections.sort()。然后使用equals()。这是O(nlogn)因为你做了两次排序，然后是O(n)比较。

2 b)如果你需要保持列表的顺序，你可以先复制两个列表。然后你可以在两个复制的列表上使用解决方案2。然而，如果复制非常昂贵，这可能没有吸引力。

这导致:

选项3

如果你的要求与2 b部分相同，但复制太昂贵。您可以使用TreeSet为您进行排序。将每个列表转储到它自己的TreeSet中。它将在集合中排序，原始列表将保持不变。然后对两个__abc1执行equals()比较。TreeSetss可以在O(nlogn)时间内构建，而equals()是O(n)。

你选吧:-)。

< em >编辑:< / em >我几乎忘记了同样的警告，劳伦斯Gonsalves指出。TreeSet实现将消除重复项。如果关心重复项，则需要某种排序的多集。

小开
你可以使用Apache的org.apache.commons.collections库: http://commons.apache.org/collections/apidocs/org/apache/commons/collections/ListUtils.html < / p > 
public static boolean isEqualList(java.util.Collection list1,
java.util.Collection list2)
小开

示例代码:

public static '<'T'>' boolean isListDifferent(List'<'T'>' previousList,
List'<'T'>' newList) {


int sizePrevoisList = -1;
int sizeNewList = -1;


if (previousList != null && !previousList.isEmpty()) {
sizePrevoisList = previousList.size();
}
if (newList != null && !newList.isEmpty()) {
sizeNewList = newList.size();
}


if ((sizePrevoisList == -1) && (sizeNewList == -1)) {
return false;
}


if (sizeNewList != sizePrevoisList) {
return true;
}


List n_prevois = new ArrayList(previousList);
List n_new = new ArrayList(newList);


try {
Collections.sort(n_prevois);
Collections.sort(n_new);
} catch (ClassCastException exp) {
return true;
}


for (int i = 0; i < sizeNewList; i++) {
Object obj_prevois = n_prevois.get(i);
Object obj_new = n_new.get(i);
if (obj_new.equals(obj_prevois)) {
// Object are same
} else {
return true;
}
}


return false;
}
小开

尝试这个版本，它不要求顺序相同，但支持有多个相同的值。只有当它们各自具有相同的值时，它们才匹配。

public boolean arraysMatch(List<String> elements1, List<String> elements2) {
// Optional quick test since size must match
if (elements1.size() != elements2.size()) {
return false;
}
List<String> work = newArrayList(elements2);
for (String element : elements1) {
if (!work.remove(element)) {
return false;
}
}
return work.isEmpty();
}
小开

我知道这是一个旧线程，但没有其他答案完全解决了我的用例(我猜Guava Multiset可能做同样的事情，但这里没有例子)。请原谅我的格式。我还是一个栈交换的新手。另外，如果有任何错误，请告诉我

假设你有List<T> a和List<T> b，你想检查它们是否等于以下条件:

1) O(n)期望运行时间
2)相等性定义为:对于a或b中的所有元素，该元素在a中出现的次数等于该元素在b中出现的次数。元素相等性定义为T.equals()

private boolean listsAreEquivelent(List<? extends Object> a, List<? extends Object> b) {
if(a==null) {
if(b==null) {
//Here 2 null lists are equivelent. You may want to change this.
return true;
} else {
return false;
}
}
if(b==null) {
return false;
}
Map<Object, Integer> tempMap = new HashMap<>();
for(Object element : a) {
Integer currentCount = tempMap.get(element);
if(currentCount == null) {
tempMap.put(element, 1);
} else {
tempMap.put(element, currentCount+1);
}
}
for(Object element : b) {
Integer currentCount = tempMap.get(element);
if(currentCount == null) {
return false;
} else {
tempMap.put(element, currentCount-1);
}
}
for(Integer count : tempMap.values()) {
if(count != 0) {
return false;
}
}
return true;
}

运行时间是O(n)，因为我们对hashmap进行了O(2*n)次插入和O(3*n)次hashmap选择。我还没有完全测试这段代码，所以要小心:)

//Returns true:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","A"));
listsAreEquivelent(null,null);
//Returns false:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),null);
小开

如果你正在使用(或乐于使用)Apache Commons Collections，你可以使用CollectionUtils.isEqualCollection，它“如果给定的Collections包含完全相同的元素和完全相同的基数，则返回true”。

小开

当两个列表具有相同的元素，但顺序不同时的解决方案:

public boolean isDifferentLists(List<Integer> listOne, List<Integer> listTwo) {
if(isNullLists(listOne, listTwo)) {
return false;
}


if (hasDifferentSize(listOne, listTwo)) {
return true;
}


List<Integer> listOneCopy = Lists.newArrayList(listOne);
List<Integer> listTwoCopy = Lists.newArrayList(listTwo);
listOneCopy.removeAll(listTwoCopy);


return CollectionUtils.isNotEmpty(listOneCopy);
}


private boolean isNullLists(List<Integer> listOne, List<Integer> listTwo) {
return listOne == null && listTwo == null;
}


private boolean hasDifferentSize(List<Integer> listOne, List<Integer> listTwo) {
return (listOne == null && listTwo != null) || (listOne != null && listTwo == null) || (listOne.size() != listTwo.size());
}
小开

除了劳伦斯的答案，如果你也想让它为零安全:

private static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
if (list1 == null)
return list2==null;
if (list2 == null)
return list1 == null;
return new HashSet<>(list1).equals(new HashSet<>(list2));
}
小开

很晚才加入这个派对，但想添加这个空安全检查:

Objects.equals(list1, list2)
小开

汤姆的回答很好，我完全同意他的回答!

这个问题的一个有趣的方面是，你是否需要List类型本身及其固有顺序。

如果不是，你可以降级为Iterable或Collection，这让你在传递数据结构时具有一定的灵活性，这些数据结构是根据插入时间排序的，而不是在你想要检查的时间排序。

如果顺序无关紧要(并且你没有重复的元素)，可以考虑使用Set。

如果顺序很重要，但由插入时间定义(并且没有副本)，则考虑LinkedHashSet，它类似于TreeSet，但按插入时间排序(副本不计算)。这也为您提供了O(1)平摊访问，而不是O(log n)。

小开

我的解决方案是针对你不关心Lists中的顺序的情况——换句话说:具有相同元素但顺序不同的Lists将被认为具有相同的内容。

示例:["word1", "word2"]和["word2", "word1"]被认为具有相同的内容。

我已经谈到了订购，我还需要说一些关于副本的事情。Lists需要具有相同数量的元素才能被认为是相等的。

例如:["word1"]和["word1", "word1"]被认为没有相同的内容。

我的解决方案:

public class ListUtil {


public static <T> boolean hasSameContents(List<T> firstList, List<T> secondList) {
if (firstList == secondList) { // same object
return true;
}
if (firstList != null && secondList != null) {
if (firstList.isEmpty() && secondList.isEmpty()) {
return true;
}
if (firstList.size() != secondList.size()) {
return false;
}
List<T> tmpSecondList = new ArrayList<>(secondList);
Object currFirstObject = null;
for (int i=1 ; i<=firstList.size() ; i++) {
currFirstObject = firstList.get(i-1);
boolean removed = tmpSecondList.remove(currFirstObject);
if (!removed) {
return false;
}
if (i != firstList.size()) { // Not the last element
if (tmpSecondList.isEmpty()) {
return false;
}
}
}
if (tmpSecondList.isEmpty()) {
return true;
}
}
return false;
}
}

我用Strings测试了它，如下所示:

@Test
public void testHasSameContents() throws Exception {
// comparing with same list => no duplicate elements
Assert.isTrue(ListUtil.hasSameContents(List.of("one", "two", "three"), List.of("one", "two", "three")));
// comparing with same list => duplicate elements
Assert.isTrue(ListUtil.hasSameContents(List.of("one", "two", "three", "one"), List.of("one", "two", "three", "one")));
// compare with disordered list => no duplicate elements
Assert.isTrue(ListUtil.hasSameContents(List.of("one", "two", "three"), List.of("three", "two", "one")));
// compare with disordered list => duplicate elements
Assert.isTrue(ListUtil.hasSameContents(List.of("one", "two", "three", "one"), List.of("three", "two", "one", "one")));
// comparing with different list => same size, no duplicate elements
Assert.isFalse(ListUtil.hasSameContents(List.of("one", "two", "three"), List.of("four", "five", "six")));
// comparing with different list => same size, duplicate elements
Assert.isFalse(ListUtil.hasSameContents(List.of("one", "two", "two"), List.of("one", "two", "three")));
Assert.isFalse(ListUtil.hasSameContents(List.of("one", "two", "three"), List.of("one", "two", "two")));
// comparing with different list => different size, no duplicate elements
Assert.isFalse(ListUtil.hasSameContents(List.of("one", "two", "three", "four"), List.of("one", "two", "three")));
Assert.isFalse(ListUtil.hasSameContents(List.of("one", "two", "three"), List.of("one", "two", "three", "four")));
// comparing with different list => different sizes, duplicate elements
Assert.isFalse(ListUtil.hasSameContents(List.of("one", "two", "three", "one"), List.of("one", "two", "three")));
Assert.isFalse(ListUtil.hasSameContents(List.of("one", "two", "three"), List.of("one", "two", "three", "one")));
}
小开
我知道这可能非常晚，但我个人使用这个函数。 如果有人想做一些基准测试，那就太好了 
public static<X> boolean areEqual(List<X> a, List<X> b, BiPredicate<X, X> AEqualsB) {
boolean aIsNull = a == null;
boolean bIsNull = b == null;
if (aIsNull || bIsNull) {
return aIsNull == bIsNull;
}
int size = a.size();
boolean sameSize = size == b.size();
if (!sameSize) {return false;} else {
for (int i = 0; i < size; i++) {
X aX = a.get(i), bX = b.get(i);
boolean areEqual = AEqualsB.test(aX, bX);
if (!areEqual) {
return false;
}
}
return true;
}
}

顺便说一句，我知道前5行可以用异或&;^&;加上另一个，但信不信由你，我很难得出正确的异或。

我想它的效率取决于谓词的类型，但同时它允许您检查自定义的潜在相等，而忽略对编码器来说可能无关紧要的差异。

下面是一个代码示例。

ListUtils.areEqual(newElements, oldElements, Element::areEqual)


public boolean areEqual(Element e) {
return optionalAdapterId() == e.optionalAdapterId()
&& value == e.value
&& valueTotal == e.valueTotal
&& stockTotal == e.stockTotal
&& element_title.equals(e.element_title);
}

至于效率,我认为任何迭代总是昂贵,这就是为什么每当我需要使用这个函数与大名单,我在一个单独的线程执行的操作,和检索响应的需要,即使它很高兴知道此时,它是有益的在一个不同的线程,是什么项目,要求这些线程的数量,这些信息将被添加文档。

小开

下面是一种比较两个集合的方法，它考虑了其中的重复。因此，集合大小不一定相同。因此，它会在'actual'中寻找'expected':

    private static <T> boolean containsAllExpected(Collection<T> actual, Collection<T> expected) {
if (actual == null && expected == null) {
return true;
}
if (actual == null || expected == null) {
return false;
}
Collection<T> a = new ArrayList<>(actual);
Collection<T> e = new ArrayList<>(expected);


Iterator<T> ei = e.iterator();
while (ei.hasNext()) {
T item = ei.next();
if (a.contains(item)) {
ei.remove();
a.remove(item);
} else {
return false;
}
}


return true;
}

享受:)

小开

这应该在O(n)时间内完成。

public static <T> boolean isEqualCollection(Collection<T> c1, Collection<T> c2){
if(nonNull(c1) && nonNull(c2)){
Map<T, Long> c1Counts = c1.stream().collect(Collectors.groupingBy(i -> i, Collectors.counting()));
for(T item : c2) {
Long count  = c1Counts.getOrDefault(item, 0L);
if(count.equals(0L)){
return false;
} else {
c1Counts.put(item, count - 1L);
}
}
return true;
}
return isNull(c1) && isNull(c2);
}
小开

!集合。disjoint(Collection1, Collection2)如果它们有相同的元素，则返回true

小开 
private boolean listHaveEqualObjects(List<?> list1, List<?> list2){
return list1.containsAll(list2) && list2.containsAll(list1);

提交答案