Java 8 – Convert Stream to Set

Introduction

Java 8 introduced the Stream API, which provides a flexible and functional approach to processing collections of data. One of the common tasks when working with streams is converting the stream’s elements into a Set. A Set in Java is a collection that contains no duplicate elements, making it ideal when you need a collection with unique elements. The Stream API provides a simple and efficient way to convert a stream into a Set, ensuring that any duplicate elements are automatically removed.

In this guide, we’ll explore how to convert a stream to a Set in Java 8, with examples demonstrating how to apply this to different types of data, including lists of integers, strings, and custom objects.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Converting a Stream of Integers to a Set
  • Converting a Stream of Strings to a Set
  • Converting a Stream of Custom Objects to a Set
• Advanced Considerations
• Conclusion

Problem Statement

The task is to create a Java program that:

• Demonstrates how to convert a stream into a Set.
• Applies this conversion to different types of data, including lists of integers, strings, and custom objects.
• Outputs the results with any duplicate elements removed.

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", "cherry"]
• Output: Set of strings: ["apple", "banana", "cherry"]

Solution Steps

1. Create a Stream: Start with a stream of elements that may contain duplicates.
2. Convert the Stream to a Set: Use the Collectors.toSet() method to collect the stream elements into a Set.
3. Display the Result: Print the elements of the set, which will contain only unique elements.

Java Program

Converting a Stream of Integers to a Set

The Collectors.toSet() method can be used to convert a stream of integers to a Set, automatically removing any duplicate elements.

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

/**
 * Java 8 - Converting a Stream of Integers to a Set
 * Author: https://www.rameshfadatare.com/
 */
public class StreamToSetInteger {

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

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

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

Output

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

Explanation

• The numbers.stream() method creates a stream from the list of integers.
• The collect(Collectors.toSet()) method collects the elements of the stream into a Set, removing any duplicates.
• The unique elements are then printed as a set.

Converting a Stream of Strings to a Set

You can also use Collectors.toSet() to convert a stream of strings into a Set, ensuring all strings are unique.

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

/**
 * Java 8 - Converting a Stream of Strings to a Set
 * Author: https://www.rameshfadatare.com/
 */
public class StreamToSetString {

    public static void main(String[] args) {
        // Step 1: Create a list of strings with duplicates
        List<String> fruits = Arrays.asList("apple", "banana", "apple", "cherry", "banana");

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

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

Output

Set of Strings: [apple, banana, cherry]

Explanation

• The fruits.stream() method creates a stream from the list of strings.
• The collect(Collectors.toSet()) method collects the elements of the stream into a Set, removing any duplicate strings.
• The unique strings are then printed as a set.

Converting a Stream of Custom Objects to a Set

When working with custom objects, you can convert a stream of these objects into a Set. To ensure that duplicates are correctly identified, the custom objects should correctly override the equals() and hashCode() methods.

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

/**
 * Java 8 - Converting a Stream of Custom Objects to a Set
 * Author: https://www.rameshfadatare.com/
 */
public class StreamToSetCustomObjects {

    public static void main(String[] args) {
        // Step 1: Create a list of products with duplicates
        List<Product> products = Arrays.asList(
            new Product("Laptop", 1500),
            new Product("Phone", 800),
            new Product("Laptop", 1500),
            new Product("Tablet", 600)
        );

        // Step 2: Convert the stream to a set
        Set<Product> productSet = products.stream()
            .collect(Collectors.toSet());

        // Step 3: Display the result
        productSet.forEach(product -> 
            System.out.println("Product: " + product.getName() + ", Price: " + product.getPrice()));
    }
}

// Custom class Product
class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Product product = (Product) o;
        return Double.compare(product.price, price) == 0 &&
                Objects.equals(name, product.name);
    }

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

Output

Product: Laptop, Price: 1500.0
Product: Phone, Price: 800.0
Product: Tablet, Price: 600.0

Explanation

• The products.stream() method creates a stream from the list of Product objects.
• The collect(Collectors.toSet()) method collects the elements of the stream into a Set, ensuring no duplicates are present based on the equals() and hashCode() implementations.
• The unique products are then printed.

Advanced Considerations

• Immutable Sets: If you need the resulting Set to be immutable, consider using Collectors.toUnmodifiableSet() available in Java 10 and later versions.

• Handling Null Values: When converting a stream to a Set, consider how null values should be handled. If your stream might contain nulls, make sure your code accounts for this.

• Ordering: Note that HashSet (which is the default Set implementation returned by Collectors.toSet()) does not maintain the order of elements. If you need an ordered set, consider using Collectors.toCollection(TreeSet::new).

Conclusion

This guide provides methods for converting a stream to a Set in Java 8, covering different types of data including integers, strings, and custom objects. Converting a stream to a Set is a simple and effective way to ensure that your collection contains only unique elements, making your code more robust and preventing issues related to duplicate data. By understanding how to use Collectors.toSet() effectively, you can simplify and enhance your data processing tasks in Java.