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

Objects.equals(list1, list2)

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

这取决于您使用的具体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()将不会拾取它。

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

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

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

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

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

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

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

list1.equals(list2)

来自javadoc:

Compares the specified object with this list for equality. Returns true if and only if the specified object is also a list, both lists have the same size, and all corresponding pairs of elements in the two lists are equal. (Two elements e1 and e2 are equal if (e1==null ? e2==null : e1.equals(e2)).) In other words, two lists are defined to be equal if they contain the same elements in the same order. This definition ensures that the equals method works properly across different implementations of the List interface.

如果你想检查与顺序无关，你可以复制所有的元素到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"， "B"]，则Set方法将认为它们相等。

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

在比较它们之前对两个列表(或副本)进行排序，就像在回答另一个问题时所做的那样 或复制所有元素到Multiset