How to prevent the adding of duplicate objects to an ArrayList ？

To avoid adding duplicate objects to an ArrayList, several strategies can be employed. Below are methods suitable for different scenarios and requirements:

1. Using HashSet to Check for Duplicates

Before adding elements, utilize HashSet (or any collection implementing the Set interface) to verify the existence of an object. As Set collections inherently disallow duplicate elements, they serve as effective tools for checking duplicates.

Example Code:

java
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class UniqueList {
    private List<Object> arrayList = new ArrayList<>();
    private Set<Object> hashSet = new HashSet<>();

    public void add(Object obj) {
        // Only add the object to the ArrayList if it does not exist in the HashSet
        if (hashSet.add(obj)) {
            arrayList.add(obj);
        }
    }

    public List<Object> getArrayList() {
        return arrayList;
    }
}

2. Overriding equals and hashCode Methods

When working with custom objects, ensure that the object classes override the equals and hashCode methods. This prevents the addition of equal objects to the ArrayList. Before adding, verify that the list does not already contain the object.

Example Code:

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

public class UniqueList {
    private List<MyObject> arrayList = new ArrayList<>();

    public void add(MyObject obj) {
        if (!arrayList.contains(obj)) {
            arrayList.add(obj);
        }
    }

    class MyObject {
        private int id;
        private String value;

        // Constructor, getters, setters omitted...

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            MyObject myObject = (MyObject) o;
            return id == myObject.id && value.equals(myObject.value);
        }

        @Override
        public int hashCode() {
            return Objects.hash(id, value);
        }
    }
}

3. Using LinkedHashSet to Maintain Insertion Order

To ensure uniqueness while maintaining insertion order, use LinkedHashSet. Internally, replace ArrayList with LinkedHashSet.

Example Code:

java
import java.util.LinkedHashSet;
import java.util.Set;

public class UniqueList {
    private Set<Object> linkedHashSet = new LinkedHashSet<>();

    public void add(Object obj) {
        linkedHashSet.add(obj);
    }

    public Set<Object> getSet() {
        return linkedHashSet;
    }
}

Each method has its advantages and disadvantages, and the choice depends on specific requirements. For instance, if insertion performance is paramount, using HashSet for duplicate checking may be optimal. If maintaining insertion order is necessary, LinkedHashSet is preferable. For frequent read operations, ArrayList with overridden equals and hashCode methods may be more suitable. Ultimately, select the method that best fits the application context and performance needs.