在标准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
我知道可能有什么东西在盯着我的脸:-)
编辑:为了澄清，我正在寻找完全相同的元素和元素的数量，按顺序。
当前回答
我知道这是一个旧线程，但没有其他答案完全解决了我的用例(我猜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);
其他回答
示例代码:
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;
}
List上的equals方法可以做到这一点，列表是有序的，所以要相等，两个List必须具有相同的元素，且顺序相同。
return list1.equals(list2);
我知道这可能非常晚，但我个人使用这个功能。 如果有人想做一些基准测试，那就太好了。
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行可以用一个异或“^”加上一个else来简化，但信不信由你，我很难得出正确的异或。
我想它的效率取决于谓词的类型，但同时它允许您检查自定义的潜在相等，而忽略对编码器来说可能无关紧要的差异。
下面是一个代码示例。
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);
}
至于效率,我认为任何迭代总是昂贵,这就是为什么每当我需要使用这个函数与大名单,我在一个单独的线程执行的操作,和检索响应的需要,即使它很高兴知道此时,它是有益的在一个不同的线程,是什么项目,要求这些线程的数量,这些信息将被添加文档。
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函数。
!集合。disjoint(Collection1, Collection2)如果它们有相同的元素，则返回true
