Java通过公共属性比较不同的对象

我有

ObjectA

和

ObjectB

。两者都有一个名为

ID

（Long）

的

属性。
我有两个
List
，
ListA
包含对象类型
ObjectA
和
ListB
包含对象类型
ObjectB

我想用
ListA
和
ListB
中的所有对象填充
ListC
，但不要重复

我无法使用
contains
方法，因为
ObjectA
和
ObjectB
是不同的对象，我必须通过属性
ID
进行比较

我知道最好的解决方案是
ObjectA
和
ObjectB
扩展
a
超级类
，但我现在无法改变这一点，我只需要找到一个临时解决方案来实现它

我试过这个：

listC.addAll(listA);    

for(int j=0; j<ListA.size(); j++) {
    for(int k=0; k<ListB.size(); k++) {
        ObjectA objectA = ((ObjectA)listA.get(j));
        ObjectB objectB = ((ObjectB)listB.get(k));

        if(!objectA.getId().equals(objectB.getId())) {
            listC.add(objectB);
        }
    }
}

listC.addAll（listA）；
对于（int j=0；j如果它们都具有相同的属性，则编写一个只有值ID的接口（这就是它们存在的原因），并在类ObjectA和ObjectB中实现它。然后您可以编写自己的比较器（使用接口的类型），或者因为您只需要equals，所以只需重写此方法（那不是干净的）。这应该是最干净的方法。
如果它们都有相同的属性，那么编写一个只有值ID的接口（这就是它们存在的原因）（可能带有getter）并在类ObjectA和ObjectB中实现它。然后您可以编写自己的比较器（带有接口类型）或者，因为您只需要equals，所以只需重写此方法（这不是干净的）。这应该是最干净的方法。
如果您想要一个“高效”的解决方案，您可以实现一个
HashSet
，它保存所有尚未使用的
ID
s

HashSet<Long> ids = new HashSet<Long>();
for (ObjectA objA: listA) {
    list.add(objA);
    ids.add(objA.getId());
}

for (ObjectB objB: listB) {
    if (!ids.contains(objB.getId())) {
        ids.add(objB.getId());
        list.add(objB);
    }
}

HashSet id=newhashset（）；
for（ObjectA objA:listA）{
列表。添加（objA）；
add（objA.getId（））；
}
对于（ObjectB objB:listB）{
如果（！ids.contains（objB.getId（）））{
add（objB.getId（））；
添加列表（objB）；
}
}
如果您想要一个“高效”的解决方案，您可以实现一个
HashSet
，它保存所有尚未使用的
ID
s

HashSet<Long> ids = new HashSet<Long>();
for (ObjectA objA: listA) {
    list.add(objA);
    ids.add(objA.getId());
}

for (ObjectB objB: listB) {
    if (!ids.contains(objB.getId())) {
        ids.add(objB.getId());
        list.add(objB);
    }
}

HashSet id=newhashset（）；
for（ObjectA objA:listA）{
列表。添加（objA）；
add（objA.getId（））；
}
对于（ObjectB objB:listB）{
如果（！ids.contains（objB.getId（）））{
add（objB.getId（））；
添加列表（objB）；
}
}
对于一个根本不需要接触类的解决方案，您可以实现一个
java.util.Comparator

比如

public class ObjectComparator implements java.util.Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        long id1 = -1L;
        long id2 = -1L;
        if(o1 instanceof ObjectA) {
            id1 = ((ObjectA)o1).getId();
        }
        if(o1 instanceof ObjectB) {
            id1 = ((ObjectB)o1).getId();
        }
        if(o2 instanceof ObjectA) {
            id2 = ((ObjectA)o2).getId();
        }
        if(o2 instanceof ObjectB) {
            id2 = ((ObjectB)o2).getId();
        }
        return Long.valueOf(id1).compareTo(Long.valueOf(id2));
    }
}

然后您可以简单地使用
java.util.TreeSet
删除重复项：

Set distinct = new TreeSet(new ObjectComparator());
distinct.addAll(listA);
distinct.addAll(listB);

当然，如果使用原始类型，您会收到编译器警告，但它应该可以工作。
对于一个根本不需要接触类的解决方案，您可以实现一个
java.util.Comparator

例如

public class ObjectComparator implements java.util.Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        long id1 = -1L;
        long id2 = -1L;
        if(o1 instanceof ObjectA) {
            id1 = ((ObjectA)o1).getId();
        }
        if(o1 instanceof ObjectB) {
            id1 = ((ObjectB)o1).getId();
        }
        if(o2 instanceof ObjectA) {
            id2 = ((ObjectA)o2).getId();
        }
        if(o2 instanceof ObjectB) {
            id2 = ((ObjectB)o2).getId();
        }
        return Long.valueOf(id1).compareTo(Long.valueOf(id2));
    }
}

然后您可以简单地使用
java.util.TreeSet
删除重复项：

Set distinct = new TreeSet(new ObjectComparator());
distinct.addAll(listA);
distinct.addAll(listB);

当然，如果使用原始类型，您将收到编译器警告，但它应该可以工作。
objectB.getId（）括号在检查
equal
时丢失。最后一个问题是属性ID有什么类型？类似于
int
？如果ID属性是您自己的类，则需要重写equals（）方法。@bmt抱歉，我的错误是复制+粘贴。edited您最好为每一个都添加一个
Map
，您可以将一个添加到另一个。虽然避免添加超级接口看起来可能更简单，但实际上这会使您的生活更困难。objectB.getId（）检查
equal
时缺少括号。最后一个括号也是属性ID的类型是什么？类似于
int
？如果ID属性是您自己的类，则需要重写equals（）方法。@bmt对不起，我的错误是复制+粘贴。编辑你最好为每一个添加一个
Map
，你可以将一个添加到另一个。虽然避免添加超级界面可能看起来更简单，但实际上会使你的生活更困难。非常感谢，你救了我一天！非常感谢，你救了我一天！非常好的解决方案。谢谢！解决方案也很好。谢谢！