removeAll方法與不同的對象類型

Question

我有兩個列表，我想要使用方法removeAll，retainAll，包含批量操作。問題是兩個列表都有不同類型的對象，其中一個字段是相同的。它像

class ObjectType1{ 
    Long field1; 
    String field2; 
    String field3 
} 

class ObjectType2{ 
Long field1; 
String field4; 
Long field5 

}

所以列表1中包含ObjectType1的元素，和List2包含ObjectType2。我想根據Field1進行批量操作，這在兩種對象類型中都很常見。

我在考慮在基於公共字段的對象中實現equals方法。但是後來認爲在將來只需要在一個字段上進行平等可能是錯誤的，因此可能需要在equals方法中添加基於其他字段的比較。請建議。

希望我已經使我的查詢足夠清楚。請讓我知道澄清。

Answer 1

嘗試下面的代碼，它會給共同價值

package rais; 

import java.util.ArrayList; 
import java.util.List; 

public class ArrayClient { 

    public static void main(String[] args) { 

     List<ObjectType1> list1 = new ArrayList<ObjectType1>(); 

     ObjectType1 type1Obj1 = new ObjectType1(10001l, "XXX", "YYYY"); 
     list1.add(type1Obj1); 

     ObjectType1 type1Obj2 = new ObjectType1(10002l, "XXX", "YYYY"); 
     list1.add(type1Obj2); 

     ObjectType1 type1Obj3 = new ObjectType1(10003l, "XXX", "YYYY"); 
     list1.add(type1Obj3); 

     ObjectType1 type1Obj4 = new ObjectType1(10004l, "XXX", "YYYY"); 
     list1.add(type1Obj4); 

     ObjectType1 type1Obj5 = new ObjectType1(10005l, "XXX", "YYYY"); 
     list1.add(type1Obj5); 

     List<ObjectType2> list2 = new ArrayList<ObjectType2>(); 

     ObjectType2 type2Obj1 = new ObjectType2(10001l, "XXX", 2000l); 
     list2.add(type2Obj1); 

     ObjectType2 type2Obj2 = new ObjectType2(10002l, "XXX", 2001l); 
     list2.add(type2Obj2); 

     ObjectType2 type2Obj3 = new ObjectType2(50002l, "XXX", 2002l); 
     list2.add(type2Obj3); 

     ObjectType2 type2Obj4 = new ObjectType2(50003l, "XXX", 2003l); 
     list2.add(type2Obj4); 

     List<ObjectType1> list3 = retainAll(list1, list2); 

     for (ObjectType1 objectType : list3) { 
      System.out.println(objectType); 
     } 

    } 

    public static List<ObjectType1> retainAll(List<ObjectType1> firstList, List<ObjectType2> secondList) { 

     List<ObjectType1> list3 = new ArrayList<ObjectType1>(); 

     for (ObjectType1 first : firstList) { 
      for (ObjectType2 second : secondList) { 
       if (first.getField1().equals(second.getField1())) { 
        list3.add(first); 
        break; 
       } 

      } 

     } 

     return list3; 

    } 

} 

在下面兩個Object上述程序

的列表

ObjectType1 type1Obj1 = new ObjectType1(10001l, "XXX", "YYYY"); 
      list1.add(type1Obj1); 

      ObjectType1 type1Obj2 = new ObjectType1(10002l, "XXX", "YYYY"); 
      list1.add(type1Obj2); 

具有共同FIELD1在兩個類項目list3將包含的僅有的兩個元件1類。

Answer 2

如果我明白你的問題吧，你想要什麼樣

class SuperObject{ 
     Long field1; 
     public SuperObject(){} 
     public void setField1(Long f){ 
      field1 = f; 
     } 
     public Long getField1(){ 
      return field1; 
     } 
     public boolean equals(Object obj){ 
    if(obj instanceof SuperObject) 
     return field1.equals(((SuperObject) obj).getField1()); 
    else 
     return false; 
} 
    } 
    class ObjectType1 extends SuperObject{ 
     String field2; 
     String field3; 
     ...  
} 

    class ObjectType2 extends SuperObject{ 
     String field4; 
     Long field5; 
     ... 
    } 

的名單應該是這樣的列表

List<SuperObject> list = new ArrayList<SuperObject>(); 
    ObjectType1 obj1 = new ObjectType1(); 
    ObjectType2 obj2 = new ObjectType2(); 
    list.add(obj1); 
    list.add(obj2); 

對象現在具有相同的平等法實施的基礎上， field1，這是在超類

Answer 3

我寫的代碼使用接口

public interface IMatchable { 

    Object getMatchingField(); 
} 

然後我ObjectType1和ObjectType2正在實施以壓倒一切沿着這條接口equals方法爲

public class ObjectType1 implements IMatchable { 

@Override 
public Object getMatchingField() { 
    return field1; 
} 
@Override 
public boolean equals(Object obj) { 
    IMatchable matchableObj = null; 
    if (obj instanceof IMatchable) { 
     matchableObj = (IMatchable) obj; 
    } else { 
     return false; 
    } 
    return matchableObj.getMatchingField().equals(this.getMatchingField()) ? true: false; 
} 
} 

同樣ObjectType2使用這些方法。

Answer 4

看看Google的Guava圖書館。您可以使用Collections2.transform來實現此目的。這裏是你會怎麼做retainAll()，例如：

import com.google.common.base.Function; 
import com.google.common.collect.Collections2; 
... 
List<ObjectType1> list1 = ...; 
List<ObjectType2> list2 = ...; 
Colection<Long> list1field1 = 
    Collections2.transform(list1, 
         new Function<ObjectType1, Long>() { 
          public Long apply(ObjectType1 input) { 
          return (null == input) ? null : input.field1; 
          } 
         }); 
Collection<Long> list2field1 = 
    Collections2.transform(list2, ...); 

// list1.retainAll(list2) based on field1 equivalence 
list1field1.retainAll(list2field1); // this affects the underlying list, ie list1. 

Answer 5

由於@Dilum寫，你可以使用谷歌的番石榴庫。
此外，如果您只有列表，則應該使用Lists.transform。
此外，如果你使用Java 8，那麼它看起來像：

List<Long> list1field1 = 
    Lists.transform(list1, input -> input == null ? null : input.field1); 

或者你也可以手動做到這一點：

// list1.removeAll(list2); 
Set<Long> set = new HashSet<Long>(); 
for (ObjectType2 o2 : list2) { 
    set.add(o2.field1); 
} 
Iterator<ObjectType1> i = list1.iterator(); 
while (i.hasNext()) { 
    if (set.contains(i.next().field1)) { 
     i.remove(); 
    } 
}