在Arraylist中重复，比较java中的各个字段

我有一个代码返回一个arrayList和一个arrayList的副本 但它似乎不起作用，我正在比较数组中的所有项

public ArrayList<ObjectList> duplicates(ArrayList<ObjectList> someObjectsList) {

    ArrayList<ObjectList> ret = new ArrayList<ObjectList>();
    for ( ObjectList aSomeObjectsList: someObjectsList) {

        String field1 = aSomeObjectsList.get1();
        String field2 = aSomeObjectsList.get2();
        String field3 = aSomeObjectsList.get3();
        String field4 = aSomeObjectsList.get4();
        for (ObjectList someObject : ret) {
            if (
                field1.trim().equals(someObject.get1())&& 
                field2.trim().equals(someObject.get2())&&
                field3.trim().equals(someObject.get3())&&
                field4.trim().equals(someObject.get4())     
                ){
                ret.add(aSomeObjectsList);

            }
        }

    }
    return ret;
} 

公共ArrayList副本（ArrayList someObjectsList）{
ArrayList ret=新的ArrayList（）；
for（ObjectList aSomeObjectsList:someObjectsList）{
String field1=aSomeObjectsList.get1（）；
String field2=aSomeObjectsList.get2（）；
String field3=aSomeObjectsList.get3（）；
String field4=aSomeObjectsList.get4（）；
for（ObjectList someObject:ret）{
如果(
field1.trim（）.equals（someObject.get1（））&&
field2.trim（）.equals（someObject.get2（））&&
field3.trim（）.equals（someObject.get3（））&&
field4.trim（）.equals（someObject.get4（））
){
ret.add（aSomeObjectsList）；
}
}
}
返回ret；
} 

但我猜我做错了什么，因为它不返回任何内容，并且我知道它在这4个字段条件下有重复

提前谢谢

    for (Object someObject : ret) {
        if (
            field1.trim().equals(someObject.get1())&& 
            field2.trim().equals(someObject.get2())&&
            field3.trim().equals(someObject.get3())&&
            field4.trim().equals(someObject.get4())     
            ){
            ret.add(aSomeObjectsList);

        }
    }

上面的循环不起作用，因为它的大小为零

给你

public Set<ObjectList> duplicates(ArrayList<ObjectList> someObjectsList) {

    Set<ObjectList> originals = new HashSet<ObjectList>();
    Set<ObjectList> duplicates = new HashSet<ObjectList>();

    for ( ObjectList aSomeObjectsList: someObjectsList) {
        boolean added = originals.add(aSomeObjectsList);
        if(!added){
            duplicates.add(aSomeObjectsList);
        }     
    }
    return duplicates;
} 

公共集重复项（ArrayList someObjectsList）{
Set originals=新HashSet（）；
Set duplicates=new HashSet（）；
for（ObjectList aSomeObjectsList:someObjectsList）{
添加的布尔值=origins.add（aSomeObjectsList）；
如果（！已添加）{
重复项。添加（aSomeObjectsList）；
}     
}
返回副本；
} 

如果您的

ObjectList

类具有

hashCode（）

和

equals（）

方法的正确实现，这将是可行的

免责声明：此实现不会提供特定对象在提供的列表中被复制多少次的信息。它只会告诉您一个特定的对象被复制了。我以为那是你的真实意图。如果你想计算，有多少次，你必须修改相应的代码

提示/建议：您应该重写

equals（）

方法，并将字段相等性检查放在那里，一劳永逸

上面的循环不起作用，因为它的大小为零

给你

public Set<ObjectList> duplicates(ArrayList<ObjectList> someObjectsList) {

    Set<ObjectList> originals = new HashSet<ObjectList>();
    Set<ObjectList> duplicates = new HashSet<ObjectList>();

    for ( ObjectList aSomeObjectsList: someObjectsList) {
        boolean added = originals.add(aSomeObjectsList);
        if(!added){
            duplicates.add(aSomeObjectsList);
        }     
    }
    return duplicates;
} 

公共集重复项（ArrayList someObjectsList）{
Set originals=新HashSet（）；
Set duplicates=new HashSet（）；
for（ObjectList aSomeObjectsList:someObjectsList）{
添加的布尔值=origins.add（aSomeObjectsList）；
如果（！已添加）{
重复项。添加（aSomeObjectsList）；
}     
}
返回副本；
} 

如果您的

ObjectList

类具有

hashCode（）

和

equals（）

方法的正确实现，这将是可行的

免责声明：此实现不会提供特定对象在提供的列表中被复制多少次的信息。它只会告诉您一个特定的对象被复制了。我以为那是你的真实意图。如果你想计算，有多少次，你必须修改相应的代码

---

提示/建议：您应该重写

equals（）

方法，并将字段相等性检查放在那里，一劳永逸。

这不应该编译-如果

aSomeObjectsList

是

对象，那么它就没有方法
get1（）
，
get2（）
，等等

您的逻辑不起作用，因为您没有对照输入
列表中的其他元素检查输入
列表中的每个元素
；相反，您正在尝试检查返回
列表

此外，这并不是检查集合中重复项的真正有效方法。更好的方法是使用
HashMap
，您可以在大致恒定的时间内检查集合成员资格。如果必须使用
列表
，则首先对其进行排序（假设对象具有自然排序），并检查相邻成员是否相等

除了这两个，只需使用
List.contains（）

您的逻辑不起作用，因为您没有对照输入
列表中的其他元素检查输入
列表中的每个元素
；相反，您正在尝试检查返回
列表

此外，这并不是检查集合中重复项的真正有效方法。更好的方法是使用
HashMap
，您可以在大致恒定的时间内检查集合成员资格。如果必须使用
列表
，则首先对其进行排序（假设对象具有自然排序），并检查相邻成员是否相等

除了这两个，只需使用
List.contains（）
以下是一种方法。我已经定义了一个基本类
ObjectList
，它展示了实现
equals
和
hashCode
的方法。注意，这假设所有内部变量都是非空的。如果这些变量可以包含null，那么在计算equals/hashCode时需要检查它。此外，此类中的对象本身也必须正确实现equals/hashCode

public class ObjectList {

    private int h;

    private Object obj1;
    private Object obj2;
    private Object obj3;
    private Object obj4;

    @Override
    public boolean equals(final Object o) {
        if (!(o instanceof ObjectList))
            return false;

        final ObjectList that = (ObjectList) o;
        return that.obj1.equals(obj1) && that.obj2.equals(obj2)
            && that.obj3.equals(obj3) && that.obj4.equals(obj4);
    }

    @Override
    public int hashCode() {
        // caches the hashcode since it could be costly to recompute every time
        // but this assumes that your object is essentially immutable 
        // (which it should be if you are using equals/hashCode. If this is not
        // true and you want to just temporarily use this when doing the duplicate
        // test, move the h variable definition from the object level to this method
        // and remove this if statement.
        if (h != 0)
            return h;

        h = obj1.hashCode();
        h = h * 31 + obj2.hashCode();
        h = h * 31 + obj3.hashCode();
        h = h * 31 + obj4.hashCode();
        return h;
    }

}

public Collection<ObjectList> duplicates(
        final Collection<ObjectList> someObjectsList) {

    final Set<ObjectList> unique = new HashSet<ObjectList>(someObjectsList);
    final ArrayList<ObjectList> ret = new ArrayList<ObjectList>(someObjectsList);
    for (final ObjectList o : unique) {
        ret.remove(o);
    }

    // The ret list now contains the duplicate instances; instances 
    // with more than two occurrences will occur multiple times still in
    // this list.
    return ret;

    // If you want a list of unique duplicate instances then, comment out the above
    // return and uncomment this one.
    // return new HashSet<ObjectList>(ret);
}

公共类对象列表{
私有inth；
私有对象obj1；
私有对象obj2；
私有对象obj3；
私有对象obj4；
@凌驾
公共布尔等于（最终对象o）{
如果（！（对象列表的实例））
返回false；
最终对象列表=（对象列表）o；
返回.obj1.equals（obj1）和&that.obj2.equals（obj2）
&&that.obj3.equals（obj3）和that.obj4.equals（obj4）；
}
@凌驾
公共int hashCode（）{
//缓存哈希代码，因为它可能