Java: Convert Array to Stream


In this tutorial, we'll be converting a Java Array into a Java Stream for primitive types, as well as objects. This can be done either via, as well as Stream.of().

A good way to turn an array into a stream is to use the Arrays class' stream() method. This works the same for both primitive types and objects.

Primitive Types

For primitive types, you can use with an array reference as the parameter.

Optionally, you can also specify the range of indices that should be used as the starting and ending point of the stream/array. If these are not supplied, the entire array will be converted:

// Entire array is used for constructing the Stream[] arr)  
// Construct Stream with a range of elements[] arr,int start_ind_Include,int end_ind_Exclude) 

Let's instantiate an array and convert it into a stream:

long[] array = {2, 5, 9, 10, 15, 18, 56};
LongStream stream =;
System.out.println("Long stream:");
stream.forEach(x -> System.out.print(x + " "));

This results in:

Long stream: 
2 5 9 10 15 18 56 

Similarly, we can create a stream from a range of indices (0,4) by supplying them as the parameters. Note the starting index of the range is included and end index is not included when a range is specified:

LongStream stream =,0,4);
System.out.println("\nLong stream from index 0 to 3:");
stream.forEach(x -> System.out.print(x + " "));

This results in:

Long stream from index 0 to 3: 
2 5 9 10 


For objects, returns a Stream of the specified object. It accepts an array reference and optionally takes in a range of indices. Let's make a String array and convert it into a Stream:

String[] array = new String[]{"John", "Jenny", "Martha", "Adam"};

// Create a Stream
Stream<String> stream =;
System.out.println("Entire array:");
stream.forEach(c -> System.out.println(c));

// Create a Stream from a range
Stream<String> streamWithRange =,0,2);

The above code generates the following output:

Entire array:



Primitive Objects

Instead of using the Arrays class, we can also use the goal class - Stream. The of() method, as the name implies, creates a Stream with a given collection, such as an array.

Keep in mind, Stream.of() returns a stream of objects, regardless of the type you're using. You'll have to flatten it for primitive types. The conversion/casting is done automatically for objects, since in that case, the Stream.of() method just calls

Let's make a primitive int array:

int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
Stream<int[]> stream = Stream.of(array);
System.out.println("\nInt stream: ");
// Need to be flattened to its primitive type
stream.flatMapToInt(Arrays::stream).forEach(x -> System.out.print(x + " "));

The flattening is done via the method, which in this case just adds redundancy to the code. Instead of using Stream.of() on primitive arrays, we can use built-in classes for these such as IntStream.

This code results in:

Int stream: 
1 2 3 4 5 6 7 8 9


Now, let's create a Stream of String type. We'll then filter out only names that start with the letter 'J':

String[] array = new String[]{"John", "Jenny", "Martha", "Adam"};

Stream<String> stream = Stream.of(array);
System.out.println("Printing only names that start with 'J'...");
stream.filter(string -> string.startsWith("J"))
        .forEach(string -> System.out.pritnln(string));

The code has the following output:

Printing only names that start with 'J'...


In this article, we've covered the two ways you can create a Stream from an array. This goes for both primitive arrays and object arrays.

The method is a straightforward one, which accepts an array reference and an optional range. The Stream.of() method calls for object types, while it requires flattening for primitive types.

Author image
I am an educator and I love mathematics and data science!