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

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

如果你关心顺序，那么只需使用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

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

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()取决于顺序。如果你不关心顺序，你有三种选择。

选项1

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

选项2

这种说法有两种变体:

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

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

这导致:

选项3

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

你选吧:-)。

编辑:我差点忘了Laurence Gonsalves指出的同样的警告。TreeSet实现将消除重复项。如果关心重复项，则需要某种排序的多集。

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. set上测试equals。列表，则对象必须覆盖hashCode函数。