How to Remove Duplicates from ArrayList in Java

Try it on GfG Practice

Input: List = [1, 10, 2, 2, 10, 3, 3, 3, 4, 5, 5]
Output: List = [1, 10, 2, 3, 4, 5]

Input: List = ["G", "e", "e", "k", "s"]
Output: List = ["G", "e", "k", "s"]

1. Using Iterator

   Approach:
   1. Get the ArrayList with duplicate values.
   2. Create another ArrayList.
   3. Traverse through the first arraylist and store the first appearance of each element into the second arraylist using contains() method.
   4. The second ArrayList contains the elements with duplicates removed.
   Below is the implementation of the above approach: Java

   // Java program to remove duplicates from ArrayList
   
   import java.util.*;
   
   public class GFG {
   
       // Function to remove duplicates from an ArrayList
       public static <T> ArrayList<T> removeDuplicates(ArrayList<T> list)
       {
   
           // Create a new ArrayList
           ArrayList<T> newList = new ArrayList<T>();
   
           // Traverse through the first list
           for (T element : list) {
   
               // If this element is not present in newList
               // then add it
               if (!newList.contains(element)) {
   
                   newList.add(element);
               }
           }
   
           // return the new list
           return newList;
       }
   
       // Driver code
       public static void main(String args[])
       {
   
           // Get the ArrayList with duplicate values
           ArrayList<Integer>
               list = new ArrayList<>(
                   Arrays
                       .asList(1, 10, 1, 2, 2, 3, 3, 10, 3, 4, 5, 5));
   
           // Print the Arraylist
           System.out.println("ArrayList with duplicates: "
                              + list);
   
           // Remove duplicates
           ArrayList<Integer>
               newList = removeDuplicates(list);
   
           // Print the ArrayList with duplicates removed
           System.out.println("ArrayList with duplicates removed: "
                              + newList);
       }
   }
   

   Output:

   ArrayList with duplicates: [1, 10, 1, 2, 2, 3, 3, 10, 3, 4, 5, 5]
   ArrayList with duplicates removed: [1, 10, 2, 3, 4, 5]
   

2. Using LinkedHashSet

   A better way (both time complexity and ease of implementation wise) is to remove duplicates from an ArrayList is to convert it into a Set that does not allow duplicates. Hence LinkedHashSet is the best option available as this do not allows duplicates as well it preserves the insertion order. Approach:
   1. Get the ArrayList with duplicate values.
   2. Create a LinkedHashSet from this ArrayList. This will remove the duplicates
   3. Convert this LinkedHashSet back to Arraylist.
   4. The second ArrayList contains the elements with duplicates removed.
   Below is the implementation of the above approach: Java

   // Java program to remove duplicates from ArrayList
   
   import java.util.*;
   
   public class GFG {
   
       // Function to remove duplicates from an ArrayList
       public static <T> ArrayList<T> removeDuplicates(ArrayList<T> list)
       {
   
           // Create a new LinkedHashSet
           Set<T> set = new LinkedHashSet<>();
   
           // Add the elements to set
           set.addAll(list);
   
           // Clear the list
           list.clear();
   
           // add the elements of set
           // with no duplicates to the list
           list.addAll(set);
   
           // return the list
           return list;
       }
   
       // Driver code
       public static void main(String args[])
       {
   
           // Get the ArrayList with duplicate values
           ArrayList<Integer>
               list = new ArrayList<>(
                   Arrays
                       .asList(1, 10, 1, 2, 2, 3, 10, 3, 3, 4, 5, 5));
   
           // Print the Arraylist
           System.out.println("ArrayList with duplicates: "
                              + list);
   
           // Remove duplicates
           ArrayList<Integer>
               newList = removeDuplicates(list);
   
           // Print the ArrayList with duplicates removed
           System.out.println("ArrayList with duplicates removed: "
                              + newList);
       }
   }
   

   Output:

   ArrayList with duplicates: [1, 10, 1, 2, 2, 3, 10, 3, 3, 4, 5, 5]
   ArrayList with duplicates removed: [1, 10, 2, 3, 4, 5]
   

3. Using Java 8 Stream.distinct()

   You can use the distinct() method from the Stream API. The distinct() method return a new Stream without duplicates elements based on the result returned by equals() method, which can be used for further processing. The actual processing of Stream pipeline starts only after calling terminal methods like forEach() or collect(). Approach:
   1. Get the ArrayList with duplicate values.
   2. Create a new List from this ArrayList.
   3. Using Stream().distinct() method which return distinct object stream.
   4. convert this object stream into List
   Below is the implementation of the above approach: Java

   // Java program to remove duplicates from ArrayList
   
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.List;
   import java.util.stream.Collectors;
   
   // Program to remove duplicates from a List in Java 8
   class GFG
   {
       public static void main(String[] args)
       {
           // input list with duplicates
           List<Integer> list = new ArrayList<>(
               Arrays.asList(1, 10, 1, 2, 2, 3, 10, 3, 3, 4, 5, 5));
               // Print the Arraylist
           System.out.println("ArrayList with duplicates: "
                              + list);
   
           // Construct a new list from the set constucted from elements
           // of the original list
           List<Integer> newList = list.stream()
                                         .distinct()
                                         .collect(Collectors.toList());
   
           // Print the ArrayList with duplicates removed
           System.out.println("ArrayList with duplicates removed: "
                              + newList);
       }
   }
   

   Output:

   ArrayList with duplicates: [1, 10, 1, 2, 2, 3, 10, 3, 3, 4, 5, 5]
   ArrayList with duplicates removed: [1, 10, 2, 3, 4, 5]