Fatal编程技术网
  • java/
  • Java 删除两个列表的共同点

Java 删除两个列表的共同点

java

Java 删除两个列表的共同点,java,Java,如何基于对象属性删除两个列表的共同点。下面，我尝试从testList2中删除与testList1包含相同str1参数的所有值 我想我可以重写正在比较的类中的equals方法，因为在使用removeAll时，equals方法是在后台使用的 testList1和testList2属于ArrayList类型，它们都包含测试对象列表 testList1.removeAll(testList2); public class Test{ private String str1; priv

如何基于对象属性删除两个列表的共同点。下面，我尝试从testList2中删除与testList1包含相同str1参数的所有值

我想我可以重写正在比较的类中的equals方法，因为在使用removeAll时，equals方法是在后台使用的

testList1和testList2属于ArrayList类型，它们都包含测试对象列表

testList1.removeAll(testList2);

public class Test{

    private String str1;
    private String str2;

    public Test(String str1 , String str2){
        this.str1 = str1;
        this.str2 = str2;
    }

    public String getStr1() {
        return str1;
    }

    public String getStr2() {
        return str2;
    }

    public boolean equals(Object o){

        Test t = (Test)o;
        return this.getStr1().equalsIgnoreCase(t.getStr2());

    }
}
如果您希望两个列表中的所有对象都没有重复的对象（至少在编辑之前我就理解了这一点）：

Set both=new HashSet（）；
addAll（testList1）；
addAll（testList2）；
//如果你真的需要使用列表而不是集合
列表结果=新的ArrayList（两个）；
当然，您仍然需要重写
equals（）
，这样集合才能理解您的意思。

如果您希望两个列表中的所有对象都不重复（至少我在编辑之前就理解了这一点）：

Set both=new HashSet（）；
addAll（testList1）；
addAll（testList2）；
//如果你真的需要使用列表而不是集合
列表结果=新的ArrayList（两个）；
当然，您仍然必须重写
equals（）
，这样集合才能理解您的意思。

是的，重写
equals（…）
应该与
removeAll（…）
一起使用，因为
ArrayList
将使用它进行相等性检查

在引擎盖下，
AbstractCollection
（它是
ArrayList
的一个超类）中的
removeAll（…）
方法将调用传递给
removeAll（…）
的集合上的
contains（entry）
包含（…）
在
ArrayList
中将使用
索引（…）
获取元素的索引，该索引依次遍历所有元素并调用
等于（…）

这就是说，很明显，使用列表的
removeAll（）
实现具有O（n2）复杂性（通过源列表循环，对于每个入口，通过参数列表循环），对于较大的列表，这可能会变得非常慢

所以，您可能希望将一组要删除的对象传递给
removeAll（…）
。这将导致O（n*log（n））的复杂性（源列表上的循环仍然存在，但对集合的
包含的
调用仅为O（log（n））。
是的，重写
等于（…）
应该与
removeAll（…）
一起工作，因为
ArrayList
将使用它进行相等性检查

在引擎盖下，
AbstractCollection
（它是
ArrayList
的一个超类）中的
removeAll（…）
方法将调用传递给
removeAll（…）
的集合上的
contains（entry）
包含（…）
在
ArrayList
中将使用
索引（…）
获取元素的索引，该索引依次遍历所有元素并调用
等于（…）

这就是说，很明显，使用列表的
removeAll（）
实现具有O（n2）复杂性（通过源列表循环，对于每个入口，通过参数列表循环），对于较大的列表，这可能会变得非常慢

所以，您可能希望将一组要删除的对象传递给
removeAll（…）
。这将导致O（n*log（n））复杂度（源列表上的循环仍然存在，但对集合的
contains
调用仅为O（log（n））

我想我可以重写正在比较的类中的equals方法，因为在使用removeAll时，equals方法是在后台使用的

如果你能的话，我也会让这些字段成为最终的

我想我可以重写正在比较的类中的equals方法，因为在使用removeAll时，equals方法是在后台使用的


如果可以的话，我也会将字段设置为最终字段。
如果testList1和testList2中存在str1，您希望将其从两个列表中删除，对吗


// Iterate till all elements
for (int i=0; i < testList.size()-1; i++) {
   Test t1 = testList1.get(i);  // Get element i of TestList1 Arr
   Test t2 = testList2.get(i);  // Get element i of TestList2 Arr

   // If t1 & t2 both contains same values in str1 & str2 
    if (t1.equuals(str1) && t2.equals(str1) ) {
       // Remove the elements from list
       testList1.remove(i);
       testlist2.remove(i);
    }
} 



希望这对你有帮助。使用对您方便的选项，两者都会起作用。
如果testList1和testList2中存在str1，您希望从两个列表中删除它，对吗


// Iterate till all elements
for (int i=0; i < testList.size()-1; i++) {
   Test t1 = testList1.get(i);  // Get element i of TestList1 Arr
   Test t2 = testList2.get(i);  // Get element i of TestList2 Arr

   // If t1 & t2 both contains same values in str1 & str2 
    if (t1.equuals(str1) && t2.equals(str1) ) {
       // Remove the elements from list
       testList1.remove(i);
       testlist2.remove(i);
    }
} 


希望这对你有帮助。使用对您方便的方法，两者都会起作用。
首先
equals（）
应该确定两个对象在逻辑上是否相等。如果当这些对象的
str1
字段相等时，这些对象在逻辑上相等，那么您可以使用equals并使用为集合定义的方法。在这种情况下，
equals（）
contract（在java.lang.Object中定义）值得一读

如果我正在使用您的代码，我更希望您通过迭代解决问题，而不是定义错误的
equals（）
方法（警告：未测试代码）：


Set strings=newhashset（listOne.size（））；
对于（测试t:listOne）{
strings.add（t.getStr1（））；
}
迭代器it=listTwo.Iterator（）；
while（it.hasNext（））{
Test t=it.next（）；
if（strings.contains（t.getStr1（））
it.remove（）；
}

首先，
equals（）
应确定两个对象在逻辑上是否相等。如果这些对象在其
str1
字段相等时在逻辑上相等，则可以使用equals并使用为集合定义的方法。在这种情况下，
equals（）
契约（在java.lang.Object中定义）这本书值得一读

如果我正在使用您的代码，我更希望您通过迭代解决问题，而不是定义错误的
equals（）
方法（警告：未测试代码）：


Set strings=newhashset（listOne.size（））；
对于（测试t:listOne）{
strings.add（t.getStr1（））；
}
迭代器it=listTwo.Iterator（）；
while（it.hasNext（））{
Test t=it.next（）；
if（strings.contains（t.getStr1（））
it.remove（）；
}

什么类是
testList1
（例如
ArrayList
，
LinkedList
，…）？@thomastestlist1

// Iterate till all elements
for (int i=0; i < testList.size()-1; i++) {
   Test t1 = testList1.get(i);  // Get element i of TestList1 Arr
   Test t2 = testList2.get(i);  // Get element i of TestList2 Arr

   // If t1 & t2 both contains same values in str1 & str2 
    if (t1.equuals(str1) && t2.equals(str1) ) {
       // Remove the elements from list
       testList1.remove(i);
       testlist2.remove(i);
    }
} 



  // This will comapre current instance and the passed instance
  public boolean equals(String toCompare, Test obj) {
    return (this.equals(toComare) && obj.equals(toComapre));
  }  



Set<String> strings = new HashSet<String>(listOne.size());
for(Test t : listOne){
   strings.add(t.getStr1());
}

Iterator<Test> it = listTwo.iterator();
while(it.hasNext()){
  Test t = it.next();
  if(strings.contains(t.getStr1())
     it.remove();
}