How to Remove Duplicates from ArrayList in Java Easily

To remove duplicates from an ArrayList in Java, convert it to a LinkedHashSet which keeps order and removes duplicates, then convert back to ArrayList. Alternatively, use Java Streams with distinct() to filter duplicates cleanly.

Syntax

Here is the common syntax to remove duplicates by using a LinkedHashSet:

• ArrayList<Type> list: Your original list with duplicates.
• LinkedHashSet<Type> set = new LinkedHashSet<>(list): Converts list to a set to remove duplicates and keep order.
• list = new ArrayList<>(set): Converts the set back to an ArrayList.

Using Java Streams:

• list = list.stream().distinct().collect(Collectors.toList()): Creates a new list with duplicates removed.

java

ArrayList<Type> list = ...; // your list with duplicates
LinkedHashSet<Type> set = new LinkedHashSet<>(list);
list = new ArrayList<>(set);

// Or using streams
list = list.stream().distinct().collect(Collectors.toList());

Example

This example shows how to remove duplicates from an ArrayList of strings using both LinkedHashSet and Java Streams.

java

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.stream.Collectors;

public class RemoveDuplicates {
    public static void main(String[] args) {
        ArrayList<String> listWithDuplicates = new ArrayList<>();
        listWithDuplicates.add("apple");
        listWithDuplicates.add("banana");
        listWithDuplicates.add("apple");
        listWithDuplicates.add("orange");
        listWithDuplicates.add("banana");

        // Remove duplicates using LinkedHashSet
        LinkedHashSet<String> set = new LinkedHashSet<>(listWithDuplicates);
        ArrayList<String> listWithoutDuplicates = new ArrayList<>(set);
        System.out.println("Without duplicates (LinkedHashSet): " + listWithoutDuplicates);

        // Remove duplicates using streams
        List<String> listWithoutDuplicatesStream = listWithDuplicates.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println("Without duplicates (Streams): " + listWithoutDuplicatesStream);
    }
}

Output

Without duplicates (LinkedHashSet): [apple, banana, orange]
Without duplicates (Streams): [apple, banana, orange]

Common Pitfalls

Common mistakes when removing duplicates from an ArrayList include:

• Using a HashSet which removes duplicates but does not keep the original order.
• Trying to remove duplicates by looping and removing items inside the loop, which can cause ConcurrentModificationException.
• Not converting back to ArrayList if you need list-specific methods.

Correct approach is to use LinkedHashSet to keep order or use streams with distinct().

java

import java.util.ArrayList;
import java.util.LinkedHashSet;

public class WrongWay {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("a");

        // Wrong: removing inside loop causes error
        // for (String s : list) {
        //     if (s.equals("a")) {
        //         list.remove(s); // throws ConcurrentModificationException
        //     }
        // }

        // Right: use LinkedHashSet
        list = new ArrayList<>(new LinkedHashSet<>(list));
        System.out.println(list); // Output: [a, b]
    }
}

Output

[a, b]

Quick Reference

Summary tips for removing duplicates from an ArrayList:

• Use LinkedHashSet to remove duplicates and keep order.
• Use Java Streams distinct() for a concise, functional style.
• Avoid modifying the list while iterating to prevent errors.
• Convert back to ArrayList if list methods are needed.

Key Takeaways

Use LinkedHashSet to remove duplicates while preserving order in an ArrayList.

Java Streams distinct() method offers a clean way to filter duplicates.

Avoid removing items from a list inside a loop to prevent runtime errors.

Always convert back to ArrayList if you need list-specific features after removing duplicates.