¿Cómo evitar la adición de elementos duplicados a Java ArrayList?

¿Alguna vez se preguntó cómo puede hacer que un ArrayList sea único? Bueno, en este artículo veremos cómo evitar la adición de duplicados en nuestra ArrayList. Si una ArrayList tiene tres elementos duplicados, pero al final, solo los que son únicos se toman en la ArrayList y las repeticiones se ignoran, se pueden hacer utilizando varios enfoques que se describen a continuación.

Ejemplo:

Input : [1, 1, 2, 2, 3, 3, 4, 5, 8]
Output: [1, 2, 3, 4, 5, 8]

Input : [1, 1, 1, 1, 1, 1, 1, 1, 1]
Output: [1]

Enfoque 1: método contains()

1. Agregar elementos uno por uno.
2. Compruebe su presencia utilizando el método contains.
3. Ignora el elemento actual si devuelve verdadero.
4. De lo contrario, agregue el elemento.

A continuación se muestra la implementación del enfoque anterior:

// Java Program to prevent the addition
// of duplicate elements to an ArrayList.
  
// Importing the ArrayList class
import java.util.ArrayList;
  
class GFG {
    public static void main(String[] args)
    {
  
        // Input
        int array[] = { 1, 1, 2, 2, 3, 3, 4, 5, 8 };
  
        // Creating an empty ArrayList
        ArrayList<Integer> ans = new ArrayList<>();
  
        for (int i : array) {
  
            // Checking if the element is already present or
            // not
            if (!ans.contains(i)) {
                // Adding the element to the ArrayList if it
                // is not present
                ans.add(i);
            }
        }
  
        // Printing the elements of the ArrayList
        for (int i : ans) {
            System.out.print(i + " ");
        }
    }
}

1 2 3 4 5 8

Complejidad de tiempo: O ( N ² ), ya que el método contiene puede atravesar toda la array en el peor de los casos.

Complejidad espacial: O(1), ya que no se utiliza espacio adicional.

Enfoque 2: HashSet

1. Agregar elementos uno por uno.
2. Verifique su presencia usando HashSet .
3. Ignora el elemento actual si devuelve verdadero.
4. De lo contrario, agregue el elemento.

 A continuación se muestra la implementación del enfoque anterior:

// Java Program to prevent the addition
// of duplicate elements to an ArrayList.
  
// Importing the ArrayList class
import java.util.ArrayList;
  
// Importing the HashSet class
import java.util.HashSet;
  
class GFG {
    public static void main(String[] args)
    {
  
        // Input
        int array[] = { 1, 1, 1, 1, 1, 1, 1, 1 };
  
        // Creating an empty ArrayList
        ArrayList<Integer> ans = new ArrayList<>();
  
        // Creating an empty HashSet
        HashSet<Integer> set = new HashSet<>();
  
        for (int i : array) {
  
            // Checking if the element is already present or
            // not
            if (!set.contains(i)) {
                // Adding the element to the ArrayList if it
                // is not present
                ans.add(i);
                // Adding the element to the HashSet if it
                // is not present
                set.add(i);
            }
        }
  
        // Printing the elements of the ArrayList
        for (int i : ans) {
            System.out.print(i + " ");
        }
    }
}

1

Complejidad de tiempo: O(n)

Complejidad espacial: O(n), ya que se utiliza un HashSet para almacenar los elementos atravesados.