How to Remove Duplicates from ArrayList in Java

Given an ArrayList with duplicate values, the task is to remove the duplicate values from this ArrayList in Java.

Examples:

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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    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]
    


My Personal Notes arrow_drop_up

Technical Content Engineer at GeeksForGeeks

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : 29AjayKumar