Java 8 – Convert Set to Array

Introduction

Converting a Set to an Array is a common task in Java, particularly when you need to interface with APIs that require arrays or when you want to perform operations that are more efficiently handled by arrays. While the traditional approach to converting a Set to an Array is still valid, Java 8 introduced the Stream API, which offers a more streamlined and readable way to perform this conversion. In this guide, we’ll explore how to convert a Set to an Array using different approaches in Java 8.

Table of Contents

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

Problem Statement

The task is to create a Java program that:

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

Example 1:

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

Example 2:

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

Solution Steps

1. Input Set: Start with a Set of elements that can either be hardcoded or provided by the user.
2. Convert Set to Array Using Streams: Use the Stream API and the toArray() method to convert the Set to an Array.
3. Display the Result: Print the resulting Array.

Java Program

Converting a Set of Strings to an Array

import java.util.HashSet;
import java.util.Set;

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

    public static void main(String[] args) {
        // Step 1: Take input set
        Set<String> fruits = new HashSet<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("orange");

        // Step 2: Convert the set to an array using streams
        String[] fruitArray = fruits.stream()
                                    .toArray(String[]::new);

        // Step 3: Display the result
        System.out.println("Converted Array: ");
        for (String fruit : fruitArray) {
            System.out.println(fruit);
        }
    }
}

Output

Converted Array:
banana
orange
apple

Explanation

• The stream() method is used to create a stream from the Set of strings.
• The toArray(String[]::new) method converts the stream into an array of String elements.
• The resulting array is printed to the console.

Converting a Set of Integers to an Array

import java.util.HashSet;
import java.util.Set;

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

    public static void main(String[] args) {
        // Step 1: Take input set
        Set<Integer> numbers = new HashSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);

        // Step 2: Convert the set to an array using streams
        Integer[] numberArray = numbers.stream()
                                       .toArray(Integer[]::new);

        // Step 3: Display the result
        System.out.println("Converted Array: ");
        for (Integer number : numberArray) {
            System.out.println(number);
        }
    }
}

Output

Converted Array:
1
2
3
4

Explanation

• The stream() method is used to create a stream from the Set of integers.
• The toArray(Integer[]::new) method converts the stream into an array of Integer elements.
• The resulting array is printed to the console.

Converting a Set of Custom Objects to an Array

import java.util.HashSet;
import java.util.Set;

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

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

        // Step 2: Convert the set to an array using streams
        Student[] studentArray = students.stream()
                                         .toArray(Student[]::new);

        // Step 3: Display the result
        System.out.println("Converted Array: ");
        for (Student student : studentArray) {
            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;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Output

Converted Array:
Vikram: 22
Raj: 25
Anita: 30

Explanation

• The stream() method is used to create a stream from the Set of Student objects.
• The toArray(Student[]::new) method converts the stream into an array of Student objects.
• The resulting array is printed to the console, showing each student’s name and age.

Advanced Considerations

• Array Type Specification: When using toArray(), you must specify the type of the array. The syntax String[]::new or Integer[]::new indicates that the stream elements should be collected into an array of that specific type.

• Null Handling: Be cautious if your Set contains null values, as these will be included in the resulting array. You can filter out nulls before conversion:

  String[] nonNullArray = set.stream()
                             .filter(Objects::nonNull)
                             .toArray(String[]::new);
  

• Performance Considerations: Converting a Set to an Array using Streams is generally efficient for typical collection sizes. However, for very large sets, consider the performance implications, especially if the conversion is part of a performance-critical code path.

Conclusion

This guide provides methods for converting a Set to an Array using Java 8 Streams, covering both simple sets like strings and integers, as well as more complex sets like custom objects. Java 8 Streams offer a concise and readable way to perform this conversion, making your code more maintainable. Depending on your specific use case, you can easily apply the techniques demonstrated in this guide to convert any Set into an Array.