Java 8 – Convert List to Set

Introduction

In Java, a List allows duplicate elements, while a Set does not. Converting a List to a Set is a common task when you want to eliminate duplicates from a collection or when you need to perform set operations. Java 8 introduced the Stream API, which makes the conversion process simple, efficient, and readable. In this guide, we’ll explore how to convert a List to a Set using different approaches in Java 8, including the Stream API, and discuss scenarios where this conversion is useful.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Converting a List to a Set Using Streams
  • Converting a List to a Set Using Constructor
  • Converting a List to an Immutable Set
• Advanced Considerations
• Conclusion

Problem Statement

The task is to create a Java program that:

• Accepts a List of elements.
• Converts the List to a Set.
• Outputs the resulting Set.

Example 1:

• Input: List of strings ["apple", "banana", "orange", "apple"]
• Output: Set of strings ["apple", "banana", "orange"]

Example 2:

• Input: List of integers [1, 2, 3, 4, 1, 2]
• Output: Set of integers [1, 2, 3, 4]

Solution Steps

1. Input List: Start with a List of elements that can either be hardcoded or provided by the user.
2. Convert the List to a Set: Use one of the methods available in Java 8 to convert the List to a Set.
3. Display the Result: Print the resulting Set.

Java Program

Converting a List to a Set Using Streams

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

/**
 * Java 8 - Convert List to Set Using Streams
 * Author: https://www.rameshfadatare.com/
 */
public class ConvertListToSet {

    public static void main(String[] args) {
        // Step 1: Take input list
        List<String> fruits = Arrays.asList("apple", "banana", "orange", "apple");

        // Step 2: Convert the list to a set using streams
        Set<String> fruitSet = fruits.stream()
                                     .collect(Collectors.toSet());

        // Step 3: Display the result
        System.out.println("Converted Set: " + fruitSet);
    }
}

Output

Converted Set: [banana, orange, apple]

Explanation

• The stream() method is used to create a stream from the List of strings.
• The Collectors.toSet() method collects the stream elements into a Set, automatically eliminating duplicates.
• The resulting Set ["banana", "orange", "apple"] is printed to the console.

Converting a List to a Set Using Constructor

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Java 8 - Convert List to Set Using Constructor
 * Author: https://www.rameshfadatare.com/
 */
public class ConvertListToSetUsingConstructor {

    public static void main(String[] args) {
        // Step 1: Take input list
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 1, 2);

        // Step 2: Convert the list to a set using HashSet constructor
        Set<Integer> numberSet = new HashSet<>(numbers);

        // Step 3: Display the result
        System.out.println("Converted Set: " + numberSet);
    }
}

Output

Converted Set: [1, 2, 3, 4]

Explanation

• The HashSet constructor takes a List as an argument and creates a Set, automatically eliminating duplicates.
• The resulting Set [1, 2, 3, 4] is printed to the console.

Converting a List to an Immutable Set

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

/**
 * Java 8 - Convert List to an Immutable Set
 * Author: https://www.rameshfadatare.com/
 */
public class ConvertListToImmutableSet {

    public static void main(String[] args) {
        // Step 1: Take input list
        List<String> fruits = Arrays.asList("apple", "banana", "orange", "apple");

        // Step 2: Convert the list to an immutable set
        Set<String> fruitSet = fruits.stream()
                                     .collect(Collectors.collectingAndThen(
                                             Collectors.toSet(),
                                             Collections::unmodifiableSet));

        // Step 3: Display the result
        System.out.println("Immutable Set: " + fruitSet);

        // Step 4: Attempt to modify the set (this should throw an exception)
        try {
            fruitSet.add("grape");
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify the immutable set.");
        }
    }
}

Output

Immutable Set: [banana, orange, apple]
Cannot modify the immutable set.

Explanation

• The Collectors.collectingAndThen() method is used to first collect the stream into a mutable Set and then wrap it in an unmodifiable (immutable) Set.
• The modification attempt (adding "grape") fails, demonstrating the immutability of the Set.

Advanced Considerations

• Performance Considerations: Converting a List to a Set using Collectors.toSet() is generally efficient for typical list sizes. For very large lists, consider the performance impact and test accordingly.

• Order Preservation: Note that the Set interface does not guarantee any particular order of elements. If you need to preserve the order, consider using a LinkedHashSet instead:

  Set<String> fruitSet = fruits.stream()
                               .collect(Collectors.toCollection(LinkedHashSet::new));
  

• Null Handling: Be cautious when converting lists with null elements to sets, as sets typically handle null differently depending on the implementation (e.g., HashSet allows one null element, but TreeSet does not).

Conclusion

This guide provides methods for converting a List to a Set using Java 8, covering approaches with Streams, constructors, and creating immutable sets. Converting a List to a Set is a useful operation when you need to eliminate duplicates or perform set-based operations, and Java 8 provides powerful tools to do this efficiently. Depending on your specific use case, you can choose the method that best fits your needs for converting collections in Java.