在标准Java库中，找出两个list是否包含完全相同的元素的最简单方法是什么?
这两个list是否为相同实例并不重要，这两个list的类型参数是否不同也不重要。
e.g.
List list1
List<String> list2;
// ... construct etc
list1.add("A");
list2.add("A");
// the function, given these two lists, should return true
我知道可能有什么东西在盯着我的脸:-)
编辑:为了澄清，我正在寻找完全相同的元素和元素的数量，按顺序。
当前回答
很晚才加入这个派对，但想添加这个空安全检查:
Objects.equals(list1, 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());
}
这应该在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);
}
List上的equals方法可以做到这一点，列表是有序的，所以要相等，两个List必须具有相同的元素，且顺序相同。
return list1.equals(list2);
如果你关心顺序，那么只需使用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
我知道这是一个旧线程，但没有其他答案完全解决了我的用例(我猜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);
