我有两个列表* *ListA<MyData> listA = new ArrayList<MyData>() **和 ListB<MyData> listB = new ArrayList<MyData>() 都包含 MyData 类型的对象和 MyData 包含这些变量。
MyData {
String name;
boolean check;
}
ListA和ListB都包含MyData对象，现在我必须比较列表的对象值 name 以及检查变量，如果 ListA 包含这些对象值
ListA = ["Ram",true],["Hariom",true],["Shiv",true];
和ListB也包含
ListB = ["Ram",true],["Hariom",true],["Shiv",true];
然后我必须比较列表并返回false，因为两个列表都是相同的 但如果ListA包含
ListA = ["Ram",true],["Hariom",true],["Shiv",false];
和 ListB 包含
ListB = ["Ram",true],["Hariom",true],["Shiv",true];
然后我必须比较列表并返回true，因为两个列表不相同
反之亦然，任何列表值的任何细微变化都必须返回true。 我必须在这里提到的一件事可以是任何顺序。
答案 0 :(得分：40)
这不是最有效的解决方案，但最简洁的代码是：
boolean equalLists = listA.size() == listB.size() && listA.containsAll(listB);
@WesleyPorter是对的。如果复制对象在集合中，则上述解决方案将无效 对于完整的解决方案，您需要迭代一个集合，以便正确处理重复的对象。
private static boolean cmp( List<?> l1, List<?> l2 ) {
// make a copy of the list so the original list is not changed, and remove() is supported
ArrayList<?> cp = new ArrayList<>( l1 );
for ( Object o : l2 ) {
if ( !cp.remove( o ) ) {
return false;
}
}
return cp.isEmpty();
}
@RoeeGavriel是对的。 return语句必须是有条件的。上面的代码已更新。
答案 1 :(得分：14)
ArrayList已使用equals方法支持此功能。引用the docs
... 换句话说，如果两个列表包含相同顺序的相同元素，则它们被定义为相等。
确实需要您在equals课程中正确实施MyData。
修改
您已更新问题，说明列表可能有不同的订单。在这种情况下，首先对列表进行排序，然后应用等于。
答案 2 :(得分：5)
我得到了上述问题的解决方案
public boolean compareLists(List<MyData> prevList, List<MyData> modelList) {
if (prevList.size() == modelList.size()) {
for (MyData modelListdata : modelList) {
for (MyData prevListdata : prevList) {
if (prevListdata.getName().equals(modelListdata.getName())
&& prevListdata.isCheck() != modelListdata.isCheck()) {
return true;
}
}
}
}
else{
return true;
}
return false;
}
已编辑： -
我们怎样才能涵盖这个......
想象一下，如果你有两个数组“A”，真“B”，真“C”，真和“A”，真“B”，真“D”，真。即使数组1有C而数组2也有D，但没有检查可以捕获（由@Patashu提到）。所以我已经做了以下更改。
public boolean compareLists(List<MyData> prevList, List<MyData> modelList) {
if (prevList!= null && modelList!=null && prevList.size() == modelList.size()) {
boolean indicator = false;
for (MyData modelListdata : modelList) {
for (MyData prevListdata : prevList) {
if (prevListdata.getName().equals(modelListdata.getName())
&& prevListdata.isCheck() != modelListdata.isCheck()) {
return true;
}
if (modelListdata.getName().equals(prevListdata.getName())) {
indicator = false;
break;
} else
indicator = true;
}
}
}
if (indicator)
return true;
}
}
else{
return true;
}
return false;
}
答案 3 :(得分：2)
首先，实施MyData.equals(Object o)和MyData.hashCode()方法。
实施equals方法后，您可以按如下方式迭代列表：
if(ListA == null && ListB == null)
return false;
if(ListA == null && ListB != null)
return true;
if(ListA != null && ListB == null)
return true;
int max = ListA.size() > ListB.size() ? ListA.size() : ListB.size();
for(int i = 0; i < max; i++) {
myData1 = ListA.get(i);
myData2 = ListB.get(i);
if(!myData1.equals(myData2)) {
return true;
}
}
return false;
答案 4 :(得分：1)
看看是否有效。
import java.util.ArrayList;
import java.util.List;
public class ArrayListComparison {
public static void main(String[] args) {
List<MyData> list1 = new ArrayList<MyData>();
list1.add(new MyData("Ram", true));
list1.add(new MyData("Hariom", true));
list1.add(new MyData("Shiv", true));
// list1.add(new MyData("Shiv", false));
List<MyData> list2 = new ArrayList<MyData>();
list2.add(new MyData("Ram", true));
list2.add(new MyData("Hariom", true));
list2.add(new MyData("Shiv", true));
System.out.println("Lists are equal:" + listEquals(list1, list2));
}
private static boolean listEquals(List<MyData> list1, List<MyData> list2) {
if(list1.size() != list2.size())
return true;
for (MyData myData : list1) {
if(!list2.contains(myData))
return true;
}
return false;
}
}
class MyData{
String name;
boolean check;
public MyData(String name, boolean check) {
super();
this.name = name;
this.check = check;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + (check ? 1231 : 1237);
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
MyData other = (MyData) obj;
if (check != other.check)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
答案 5 :(得分：1)
我在List Compare找到了一个非常基本的List比较示例 此示例首先验证大小，然后检查另一个列表中特定元素的可用性。
答案 6 :(得分：1)
使用java 8 removeIf来比较类似的项目
public int getSimilarItems(){
List<String> one = Arrays.asList("milan", "dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta");
List<String> two = new ArrayList<>(Arrays.asList("hafil", "iga", "binga", "mike", "dingo")); //Cannot remove directly from array backed collection
int initial = two.size();
two.removeIf(one::contains);
return initial - two.size();
}
答案 7 :(得分：0)
覆盖班级中的equals方法，并使用Collection#equals()方法检查是否相等。
答案 8 :(得分：0)
逻辑应该是这样的：
第一步：对于MyData类实现Comparable接口，根据每个对象的要求覆盖compareTo方法。
第二步：说到列表比较（检查空值后）， 2.1检查两个列表的大小，如果相等则返回true，否则返回false，继续对象迭代 2.2如果步骤2.1返回true，则迭代两个列表中的元素并调用类似的内容
listA.get（ⅰ）.compareTo（listB.get（i））的
这将按照步骤1中提到的代码进行。
答案 9 :(得分：0)
您可以使用CollectionUtils.subtract从另一个列表中减去一个列表，如果结果是空集合，则表示两个列表都相同。另一种方法是使用CollectionUtils.isSubCollection或CollectionUtils.isProperSubCollection。
对于任何情况，您都应该为对象实现equals和hashCode方法。
答案 10 :(得分：0)
从那以后已经有5年了，幸运的是我们现在有了Kotlin 现在比较两个列表看起来很简单：
fun areListsEqual(list1 : List<Any>, list2 : List<Any>) : Boolean {
return list1 == list2
}
或者只是随意省略它并使用相等运算符。
答案 11 :(得分：0)
我知道它的老问题，但万一需要它。我在我的应用程序中使用它，它运行良好。我用它来检查购物车是否已经更换。
private boolean validateOrderProducts(Cart cart) {
boolean doesProductsChanged = false;
if (originalProductsList.size() == cart.getCartItemsList().size()) {
for (Product originalProduct : originalProductsList) {
if (!doesProductsChanged) {
for (Product cartProduct : cart.getCartProducts()) {
if (originalProduct.getId() == cartProduct.getId()) {
if (originalProduct.getPivot().getProductCount() != cartProduct.getCount()) {
doesProductsChanged = true;
// cart has been changed -> break from inner loop
break;
}
} else {
doesProductsChanged = false;
}
}
} else {
// cart is already changed -> break from first loop
break;
}
}
} else {
// some products has been added or removed (simplest case of Change)
return true;
}
return doesProductsChanged;
}
答案 12 :(得分：0)
String myData1 = list1.toString();
String myData2 = list2.toString()
return myData1.equals(myData2);
where :
list1 - List<MyData>
list2 - List<MyData>
比较String对我有用。另外请注意，我已经在MyData类中重写了toString（）方法。
答案 13 :(得分：0)
我认为您可以对两个列表进行排序，如果其中一些是HashSet集合，则可以转换为List。
java.utils.Collections 包使您可以做到这一点。
List<Category> categoriesList = new ArrayList<>();
Set<Category> setList = new HashSet<>();
Collections.sort(categoriesList);
List<Category> fileCategories = new ArrayList<>(setList);
Collections.sort(fileCategories);
if(categoriesList.size() == fileCategories.size() && categoriesList.containsAll(fileCategories)) {
//Do something
}
答案 14 :(得分：0)
这可以通过Java8的forEach和removeIf方法轻松完成。
采取两个清单。从 listA 进行迭代并比较 listB
中的元素在 removeIf 方法内写入任何条件。
希望这会有所帮助
listToCompareFrom.forEach(entity -> listToRemoveFrom.removeIf(x -> x.contains(entity)));