Java 8 – Convert List to Set

Introduction

Converting a list to a set is a common operation in Java, especially when you need to remove duplicates or enforce uniqueness in a collection. A Set automatically eliminates duplicate elements, making it an ideal choice when you need to ensure that all elements are distinct. With the introduction of Streams in Java 8, converting a list to a set has become more straightforward and concise. In this guide, we will explore how to convert a list to a set using Java 8 Streams, covering different scenarios including handling custom objects.

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 integers [1, 2, 2, 3, 4, 4, 5]
• Output: Set of integers [1, 2, 3, 4, 5]

Example 2:

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

Solution Steps

1. Input List: Start with a list of elements that can either be hardcoded or provided by the user.
2. Convert List to Set Using Streams: Use the Collectors.toSet() method to convert the list into a set.
3. Display the Result: Print the set.

Java Program

Convert List of Integers to Set Using Streams

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

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

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

        // Step 2: Convert the list to set using streams
        Set<Integer> numberSet = numbers.stream()
                                        .collect(Collectors.toSet());

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

Output

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

Explanation

In this example, the stream() method is used to convert the list of integers into a stream. The collect(Collectors.toSet()) method then collects the elements into a Set, automatically removing any duplicates. The resulting set contains only unique elements from the list.

Convert List of Strings to Set Using Streams

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

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

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

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

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

Output

Set: [banana, orange, apple]

Explanation

This example converts a list of strings into a set using the same method as the previous example. The Collectors.toSet() method ensures that the set contains only unique elements, removing any duplicate entries from the original list. The resulting set contains the unique fruits from the list.

Convert List of Custom Objects to Set Using Streams

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

/**
 * Java 8: Convert List of Custom Objects to Set Using Streams
 * Author: https://www.rameshfadatare.com/
 */
public class ConvertListToSetCustomObjects {

    public static void main(String[] args) {
        // Step 1: Take input list of custom objects
        List<Student> students = Arrays.asList(
                new Student("Raj", 25),
                new Student("Anita", 30),
                new Student("Raj", 25),  // Duplicate
                new Student("Vikram", 22)
        );

        // Step 2: Convert the list to set using streams
        Set<Student> studentSet = students.stream()
                                          .collect(Collectors.toSet());

        // Step 3: Display the result
        studentSet.forEach(student -> 
            System.out.println(student.getName() + ": " + student.getAge())
        );
    }
}

// Custom class Student
class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Override equals and hashCode to ensure correct behavior in Set
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Output

Raj: 25
Anita: 30
Vikram: 22

Explanation

In this example, a list of Student objects is converted into a set. To ensure that duplicate Student objects (i.e., those with the same name and age) are not added to the set, the Student class overrides the equals() and hashCode() methods. The Collectors.toSet() method is used to collect the unique Student objects into a set. The output shows that the duplicate Student ("Raj", 25) was removed, resulting in a set of unique Student objects.

Advanced Considerations

1. Handling Null Values: If the list contains null values and you want to remove them, you can filter them out before collecting the elements into a set:

   Set<String> set = list.stream()
                         .filter(Objects::nonNull)
                         .collect(Collectors.toSet());
   

2. Ordering of Elements: A Set does not maintain the order of elements. If you need to maintain insertion order, consider using a LinkedHashSet:

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

3. Performance Considerations: Converting a list to a set using Streams is efficient for typical list sizes. The performance is comparable to using traditional loops, but Streams provide more readability and flexibility.

Conclusion

This guide provides methods for converting a list to a set using Java 8 Streams, covering basic scenarios like removing duplicates and handling custom objects. Java 8 Streams offer a powerful and concise way to perform this conversion, making your code more readable and maintainable. Depending on your specific use case, you can easily apply the techniques demonstrated in this guide to achieve the desired result.