Java 检查arraylist中的重复对象id

我有一个对象列表，我想检测对象Id是否重复。 以下是对象：

public class data{
private String id;
private String value;
private String status;
}

所有重复的

数据

将具有“无效”

状态

，第一个除外

---

最有效的方法是什么？

列出对象的

id

。在对象列表上循环。查看每个对象的

id

是否已在列表中。如果

id

已经存在，则更改对象的

状态。否则，将对象的
id
添加到列表中。
使用java ConcurrentHashMap而不是arraylist

ConcurrentHashMap<yourid, YourBean> chp = new ConcurrentHashMap<>();
chp.putIfAbsent(yourid, YourBean);

ConcurrentHashMap chp=new ConcurrentHashMap（）；
chp.putIfAbsent（yourid，YourBean）；

要列出你所有的id，你可以这样做

  for (Entry<yourid, YourBean> e : chp.entrySet()) 
{
 YourBean object = (YourBean )chp.get(e.getKey());
//do what u want with your object, guess that helps
}

public class Test {

        public static void main(String[] args ) {

            List<data> dataList=new ArrayList<>();
            dataList.add(new data("1","somevalue","somestatus"));
            dataList.add(new data("1","somevalue","somestatus"));
            dataList.add(new data("1","somevalue","somestatus"));
            dataList.add(new data("2","somevalue","somestatus"));
            dataList.add(new data("3","somevalue","somestatus"));
            List<data>validList=new ArrayList<>();
            List<data>duplicateList=new ArrayList<>();

            for (data data:dataList){
                if (!(validList.contains(data))){
                    validList.add(data);
                    System.out.println(validList);
                }else{
                    duplicateList.add(data);
                    System.out.println(duplicateList);
                }
            }

        }

for（条目e:chp.entrySet（））
{
YourBean对象=（YourBean）chp.get（e.getKey（））；
//用你的物体做你想做的，猜猜这会有帮助
}
< /代码> 您可以考虑重写数据类的.等式（）方法。
这样做将允许您执行以下操作以检查重复的元素：

ArrayList<data> array_list = new ArrayList<data>();

// add some elements to array list

// check for duplicates
for(int i =0; i < array_list.size(); i++){
    for(int j=0; j<array_list.size(); j++){
        // compare for equality if it is not the same element
        if(i != j){
            if(array_list.get(i).equals(arrayList.get(j))){
                // than we know there is a duplicate at index i,j
                System.out.println("duplicate indexes: " + i + ", " + "j");
            }
        }
    }
}

编辑
如果只想知道id是否相等，则不需要重写数据类的.equals（）

@Override
public boolean equals(Object obj) {
    if (!(obj instanceof data)){ return false; }
    if (obj == this) { return true; }

    // compare strings to see if they are equal
    data other_data = (data)obj;
    boolean id_equal = other_data.id.equals(this.id);
    boolean value_equal = other_data.value.equals(this.value);
    boolean status_equal = other_data.status.equals(this.status);

    return id_equal && value_equal && status_equal
}

在这种情况下，您只需要使用第一个循环并比较id Sting而不是数据对象

因此，与array_list.get（i）.equals（arrayList.get（j））不同，
您可以这样做（假设您有用于数据私有成员的getter方法）：
数组_list.get（i）.get（id）.equals（数组_list.get（j）.get（id））

或者，您可以使用与第一个方法类似的方法，并重写.equals（）以仅比较id字符串。
首先尝试这样做，您应该重写
equals
方法以检查重复项

private  class data{
        private String id;
        private String value;
        private String status;

        public data(String id, String value, String status) {
            this.id = id;
            this.value = value;
            this.status = status;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }

        public String getStatus() {
            return status;
        }

        public void setStatus(String status) {
            this.status = status;
        }

        @Override
        public String toString() {
            return "data{" +
                    "id='" + id + '\'' +
                    '}';
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof data)) return false;

            data data = (data) o;

            return !(id != null ? !id.equals(data.id) : data.id != null);

        }

        @Override
        public int hashCode() {
            return id != null ? id.hashCode() : 0;
        }
    }

然后像这样测试

  for (Entry<yourid, YourBean> e : chp.entrySet()) 
{
 YourBean object = (YourBean )chp.get(e.getKey());
//do what u want with your object, guess that helps
}

public class Test {

        public static void main(String[] args ) {

            List<data> dataList=new ArrayList<>();
            dataList.add(new data("1","somevalue","somestatus"));
            dataList.add(new data("1","somevalue","somestatus"));
            dataList.add(new data("1","somevalue","somestatus"));
            dataList.add(new data("2","somevalue","somestatus"));
            dataList.add(new data("3","somevalue","somestatus"));
            List<data>validList=new ArrayList<>();
            List<data>duplicateList=new ArrayList<>();

            for (data data:dataList){
                if (!(validList.contains(data))){
                    validList.add(data);
                    System.out.println(validList);
                }else{
                    duplicateList.add(data);
                    System.out.println(duplicateList);
                }
            }

        }

公共类测试{
公共静态void main（字符串[]args）{
List dataList=new ArrayList（）；
添加（新数据（“1”、“somevalue”、“somestatus”）；
添加（新数据（“1”、“somevalue”、“somestatus”）；
添加（新数据（“1”、“somevalue”、“somestatus”）；
添加（新数据（“2”、“somevalue”、“somestatus”）；
添加（新数据（“3”、“somevalue”、“somestatus”）；
ListvalidList=新的ArrayList（）；
ListduplicateList=新的ArrayList（）；
用于（数据：数据列表）{
如果（！（有效列表包含（数据）））{
有效列表。添加（数据）；
System.out.println（有效列表）；
}否则{
重复列表。添加（数据）；
系统输出打印项次（重复列表）；
}
}
}
没有太多的代码和艰苦的工作…我会称之为圣诞奇迹！！看看这个我认为他的问题是
私有字符串id；
是
私有的
，与
对象的真实id没有关系…但我可能错了…看这篇文章不需要单独列出。只需使用
Getter
和iterate+与-1比较（直到固定）。我们需要一个列表，以便对于对象列表，只有具有唯一id的第一个对象不会具有无效状态。我不是只检查一个对象，因此我需要一个列表。您不需要第二个列表来知道第一个列表中是否有重复项。您可以使用简单的
循环
检查多个对象。