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

在标准Java库中查找两个List是否包含完全相同的元素的最简单方法是什么？

两个列表是否为同一实例无关紧要，并且列表的类型参数是否不同也无关紧要。

例如

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

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

我认识的脸上可能有些东西盯着我:-)

编辑：为澄清起见，我一直在按顺序寻找完全相同的元素和元素数量。

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

list1.equals(list2)

从javadoc：

比较指定对象与此列表是否相等。当且仅当指定对象也是一个列表，并且两个列表具有相同的大小，并且两个列表中所有对应的元素对相等时，才返回true。（如果（e1 == null？e2 == null：e1.equals（e2）），则两个元素e1和e2相等。）换句话说，如果两个列表包含相同顺序的相同元素，则它们被定义为相等。 。此定义确保equals方法可在List接口的不同实现中正常工作。

如果要独立于顺序进行检查，则可以将所有元素复制到Sets并在结果Sets上使用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”，“ B”]，则该Set方法将认为它们相等。

如果您需要对订单不敏感但对重复的频率敏感，则可以：

• 在比较它们之前对两个列表（或副本）进行排序，就像对另一个问题的答案一样
• 或将所有元素复制到多集

我在评论中张贴了一堆东西，我认为它值得自己回答。

就像大家在这里所说的，使用equals（）取决于顺序。如果您不关心订单，则有3种选择。

选项1

使用containsAll()。我认为该选项不是理想的，因为它提供了最差情况的性能O（n ^ 2）。

选项2

有两种变体：

2a）如果您不关心维护列表的顺序，请Collections.sort()在两个列表上使用。然后使用equals()。这是O（nlogn），因为您进行了两种排序，然后进行了O（n）比较。

2b）如果您需要维护列表的顺序，则可以先复制两个列表。然后，您可以在两个复制的列表上使用解决方案2a。但是，如果复制非常昂贵，这可能没有吸引力。

这导致：

选项3

如果您的要求与第2b部分相同，但是复制过于昂贵。您可以使用TreeSet为您进行排序。将每个列表转储到其自己的TreeSet中。它将在集合中排序，并且原始列表将保持不变。然后equals()对两个进行比较TreeSet。TreeSets可以在O（nlogn）时间建立，而s equals()是O（n）。

选择：-)。

编辑：我几乎忘了劳伦斯·贡萨尔维斯（Laurence Gonsalves）指出的警告。TreeSet实现将消除重复项。如果您关心重复项，则需要某种排序的多重集。

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

参加聚会很晚，但想添加此null安全检查：

Objects.equals(list1, list2)

我知道这是一个旧线程，但是没有其他答案可以完全解决我的用例（我猜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），因为我们正在将O（2 * n）插入到哈希图中，然后选择O（3 * n）哈希图。我尚未完全测试此代码，所以请注意:)

//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);

尝试使用此版本，该版本不需要顺序相同，但是支持具有多个相同值。仅当每个具有相同数量的任何值时，它们才匹配。

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();
}

List上的equals方法将执行此操作，因为List是有序的，因此两个List必须具有相同顺序的相同元素才能相等。

return list1.equals(list2);

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

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());
}

汤姆的答案非常好，我完全同意他的答案！

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

如果不是这样，您可以降级为Iterable或Collection为您提供一些灵活性，以便传递按插入时间而不是您要检查的时间排序的数据结构。

如果顺序无关紧要（并且您没有重复的元素），请考虑使用Set。

如果顺序很重要，但是由插入时间定义（并且您没有重复项），请考虑LinkedHashSet类似于TreeSet的a ，但按插入时间进行排序（不计算重复项）。这也为您O(1)分配了的分期付款访问权O(log n)。

样例代码：

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;
}

除了Laurence的答案，如果您还想使其成为null安全的：

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));
}

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而不是a上测试是否等于java.util.List，则您的对象必须覆盖该hashCode 函数。

List.equals（）

http://java.sun.com/j2se/1.5/docs/api/java/util/List.html#equals(java.lang.Object）

您可以使用Apache的org.apache.commons.collections库：http : //commons.apache.org/collections/apidocs/org/apache/commons/collections/ListUtils.html

public static boolean isEqualList(java.util.Collection list1,
                              java.util.Collection list2)

检查两个列表都不为空。如果它们的大小不同，则这些列表不相等。构建由列表元素作为键，并将其重复元素作为值组成的地图，并比较这些地图。

假设，如果两个列表都为空，则我认为它们相等。

private boolean compareLists(List<?> l1, List<?> l2) {
    if (l1 == null && l2 == null) {
        return true;
    } else if (l1 == null || l2 == null) {
        return false;
    }

    if (l1.size() != l2.size()) {
        return false;
    }

    Map<?, Integer> m1 = toMap(l1);
    Map<?, Integer> m2 = toMap(l2);

    return m1.equals(m2);
}

private Map<Object, Integer> toMap(List<?> list) {
    //Effective size, not to resize in the future.
    int mapSize = (int) (list.size() / 0.75 + 1);
    Map<Object, Integer> map = new HashMap<>(mapSize);

    for (Object o : list) {
        Integer count = map.get(o);
        if (count == null) {
            map.put(o, 1);
        } else {
            map.put(o, ++count);
        }
    }

    System.out.println(map);
    return map;
}

请注意，应该为这些对象正确定义方法等于。 https://stackoverflow.com/a/24814634/4587961

这取决于您使用的具体List类。抽象类AbstractCollection具有一个名为containsAll（Collection）的方法，该方法采用另一个集合（List是一个集合），并且：

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

因此，如果传入ArrayList，则可以调用此方法以查看它们是否完全相同。

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

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

    foo.containsAll(bar);

containsAll（）的原因是因为它遍历第一个列表以在第二个列表中查找匹配项。因此，如果它们不正常，equals（）将不会接收它。

编辑：我只想在这里对执行所提供的各种选项的摊销运行时间发表评论。运行时间重要吗？当然。这是您唯一要考虑的事情吗？没有。

将列表中的每个元素复制到其他列表中需要花费时间，并且还占用了大量内存（有效地使您正在使用的内存加倍）。

因此，如果您不必担心JVM中的内存（通常应该如此），那么您仍然需要考虑将每个元素从两个列表复制到两个TreeSet中所花费的时间。请记住，它是对进入每个元素的每个元素进行排序。

我的最终建议？您需要考虑数据集以及数据集中有多少个元素，以及数据集中每个对象的大小，然后才能在此处做出正确的决定。与他们一起玩耍，每种方式创建一种，看看哪种运行速度更快。这是一个很好的锻炼。