How To Convert Collection To String Array In Java?

The most robust and modern way to convert a Collection<String> to a String[] in Java is using the Collection.toArray(String[]::new) method, available since Java 11. For older versions, the toArray(new String[0]) method is the standard approach.

Core method: Collection.toArray()

The java.util.Collection interface provides two versions of the toArray() method for conversion:

1. Object[] toArray(): This method returns an Object[] containing all the elements. A direct cast to String[] will result in a ClassCastException at runtime because the runtime type of the returned array is Object[], not String[].
2. <T> T[] toArray(T[] a): This method is designed to provide type safety. It returns an array of the specified type. The key is to pass an array of the correct type as an argument to guide the conversion.

Conversion method 1: toArray(String[]::new) (Java 11+)

This is the most concise and efficient method for converting a collection to a typed array. It uses a method reference to the String[] constructor as a generator function.

How it works

The toArray(IntFunction<T[] generator>) method accepts a function that takes an integer (the size) and produces a new array of the desired type. String[]::new is the constructor reference for the String[] type. The Java runtime automatically calls this generator to create a new String[] of the correct size to hold the collection's elements.

Example:

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class CollectionToStringArrayModern {
    public static void main(String[] args) {
        // Create a Collection of Strings
        Collection<String> myCollection = new ArrayList<>();
        myCollection.add("Apple");
        myCollection.add("Banana");
        myCollection.add("Cherry");
        // Convert the Collection to a String array using the modern syntax
        String[] stringArray = myCollection.toArray(String[]::new);
        // Print the contents of the new array
        for (String s : stringArray) {
            System.out.println(s);
        }
    }
}

Use code with caution.

Why it's the best option

• Concise and readable: The syntax is clean and clearly expresses the intent.
• Type-safe: It eliminates the ClassCastException risk and returns the precise type required.
• Optimal performance: Internally, it is highly optimized to create the array and copy the elements.

Conversion method 2: toArray(new String[0]) (Legacy, Pre-Java 11)

Before the modern constructor reference syntax, this was the standard, type-safe approach. It uses the T[] toArray(T[] a) overload.

How it works

You provide an empty array (new String[0]) to the toArray() method. This array serves two purposes:

1. Type token: It tells the method what type of array to create and return (String[] in this case).
2. Size hint: The toArray() method checks if the provided array is large enough. If it's not, it creates a new, properly sized array of the correct type. The convention of passing a zero-length array is efficient because it forces a new, correctly sized array to be allocated every time.

Example:

import java.util.ArrayList;
import java.util.List;
public class CollectionToStringArrayLegacy {
    public static void main(String[] args) {
        List<String> myCollection = new ArrayList<>();
        myCollection.add("Apple");
        myCollection.add("Banana");
        myCollection.add("Cherry");
        // Convert the Collection to a String array using the legacy method
        String[] stringArray = myCollection.toArray(new String[0]);
        // Print the contents of the new array
        for (String s : stringArray) {
            System.out.println(s);
        }
    }
}

Use code with caution.

Why new String[0] and not new String[myCollection.size()]?

Passing a pre-sized array (new String[myCollection.size()]) is a common anti-pattern. While it might seem like a micro-optimization to save one new array allocation, it's actually slower in practice due to the overhead of array bounds checking. The JVM's implementation for toArray(new T[0]) is highly optimized.

Conversion method 3: Using the Stream API

For more complex conversion scenarios, such as converting a Collection<Object> to a String[] or applying intermediate operations, the Stream API is the ideal tool.

How it works

This approach involves the following steps:

1. Create a stream: Call .stream() on the collection to get a Stream<E>.
2. Map to a new type: Use the .map() method to transform each element of the stream. For example, .map(Object::toString) calls toString() on each element.
3. Collect to an array: Use the toArray(String[]::new) collector to convert the stream back into a String[].

Example for a Collection<Object>:

import java.util.ArrayList;
import java.util.List;
public class ObjectCollectionToStringArray {
    public static void main(String[] args) {
        List<Object> myObjectList = new ArrayList<>();
        myObjectList.add("Apple");
        myObjectList.add(100);
        myObjectList.add(true);
        // Convert the Collection of Objects to a String array using the Stream API
        String[] stringArray = myObjectList.stream()
                                           .map(Object::toString)
                                           .toArray(String[]::new);
        // Print the contents of the new array
        for (String s : stringArray) {
            System.out.println(s);
        }
    }
}

Use code with caution.

Key stream operations for conversion

• .map(Object::toString): Transforms each element into its string representation.
• .filter(Objects::nonNull): If your collection might contain null elements, this step prevents a NullPointerException when calling .toString() on a null value.
• .toArray(String[]::new): The terminal operation that collects the elements into a String[].

Pitfalls to avoid

Casting toArray() result

As mentioned, directly casting the result of collection.toArray() to a String[] will throw a ClassCastException.

Incorrect example:

List<String> list = List.of("a", "b");
String[] wrongArray = (String[]) list.toArray(); // This will throw a ClassCastException

Use code with caution.

Explanation: The toArray() method with no arguments returns a Object[], not a String[]. An Object[] cannot be cast to a String[] at runtime, even if all its elements are strings, because arrays are not type-erased in the same way collections are.

Null elements

Calling .toString() on a null object will result in a NullPointerException. Be sure to filter for null elements if necessary when using the Stream API.

Summary of conversion methods