Java 8 – How to Remove Duplicates from a List with Lambda

Introduction

Java 8 introduced lambda expressions and the Stream API, which allow you to process collections more efficiently and concisely. One common task when working with lists is removing duplicate elements. Traditionally, this required manual iteration and checks, but with the Stream API, you can achieve this in a much simpler way.

In this guide, we’ll explore how to remove duplicates from a list using lambda expressions and the Stream API in Java 8.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Removing Duplicates from a List
• Advanced Considerations
• Conclusion

Problem Statement

When working with lists, you may often need to ensure that all elements are unique. Removing duplicates manually can be error-prone and time-consuming. The goal is to create a Java program that removes duplicate elements from a list in a simple and efficient manner using Java 8 features.

Example:

• Input: A list with elements [1, 2, 2, 3, 4, 4, 5].
• Output: A list with duplicates removed, resulting in [1, 2, 3, 4, 5].

Solution Steps

1. Create a List: Define a list that contains some duplicate elements.
2. Use the Stream API: Utilize the distinct() method to filter out duplicate elements.
3. Collect the Results: Use Collectors.toList() to collect the distinct elements back into a list.

Java Program

Removing Duplicates from a List

Here’s a simple example that demonstrates how to remove duplicates from a list of integers using the Stream API and lambda expressions:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - How to Remove Duplicates from a List with Lambda
 * Author: https://www.rameshfadatare.com/
 */
public class RemoveDuplicatesExample {

    public static void main(String[] args) {
        // Step 1: Create a list with duplicate elements
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);

        // Step 2: Remove duplicates using the Stream API and lambda expressions
        List<Integer> distinctNumbers = numbers.stream()
            .distinct()  // Removes duplicate elements
            .collect(Collectors.toList());  // Collects the result into a list

        // Step 3: Display the list after removing duplicates
        System.out.println("List after removing duplicates: " + distinctNumbers);
    }
}

Output

List after removing duplicates: [1, 2, 3, 4, 5]

Explanation

• List Creation: The list numbers is created with some duplicate elements.
• Removing Duplicates: The distinct() method filters out duplicate elements from the stream. This method ensures that only unique elements are retained.
• Collecting Results: The Collectors.toList() method is used to collect the distinct elements back into a new list called distinctNumbers.
• Displaying the Results: The final list without duplicates is printed to the console.

Advanced Considerations

• Custom Objects: If you’re working with a list of custom objects, ensure that the equals() and hashCode() methods are properly overridden in your class, as distinct() relies on these methods to determine uniqueness.

• Performance: For very large lists, consider the performance implications. While distinct() is efficient, using a Set for deduplication may be more performant in some cases.

• Preserving Order: The distinct() method preserves the order of elements as they first appear in the list. If you need a different order, you can chain the sorted() method after distinct().

Conclusion

Removing duplicates from a list in Java 8 is simple and efficient with lambda expressions and the Stream API. The distinct() method provides a clean way to ensure that your list contains only unique elements, making your code more concise and readable. Whether you’re dealing with simple types like integers or more complex custom objects, this approach is a valuable addition to your Java toolkit.