In Java 8, you can either use Arrays.stream or Stream.of to convert an Array into a Stream.
1. Object Arrays
For object arrays, both Arrays.stream and Stream.of returns the same output.
TestJava8.java
package com.mkyong.java8;
import java.util.Arrays;
import java.util.stream.Stream;
public class TestJava8 {
public static void main(String[] args) {
String[] array = {"a", "b", "c", "d", "e"};
//Arrays.stream
Stream<String> stream1 = Arrays.stream(array);
stream1.forEach(x -> System.out.println(x));
//Stream.of
Stream<String> stream2 = Stream.of(array);
stream2.forEach(x -> System.out.println(x));
}
}
Output
a b c d e a b c d e
Review the JDK source code.
Arrays.java
/**
* Returns a sequential {@link Stream} with the specified array as its
* source.
*
* @param <T> The type of the array elements
* @param array The array, assumed to be unmodified during use
* @return a {@code Stream} for the array
* @since 1.8
*/
public static <T> Stream<T> stream(T[] array) {
return stream(array, 0, array.length);
}
Stream.java
/**
* Returns a sequential ordered stream whose elements are the specified values.
*
* @param <T> the type of stream elements
* @param values the elements of the new stream
* @return the new stream
*/
@SafeVarargs
@SuppressWarnings("varargs") // Creating a stream from an array is safe
public static<T> Stream<T> of(T... values) {
return Arrays.stream(values);
}
Note
For object arrays, the
For object arrays, the
Stream.of method is calling the Arrays.stream internally.
2. Primitive Arrays
For primitive array, the Arrays.stream and Stream.of will return different output.
TestJava8.java
package com.mkyong.java8;
import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class TestJava8 {
public static void main(String[] args) {
int[] intArray = {1, 2, 3, 4, 5};
// 1. Arrays.stream -> IntStream
IntStream intStream1 = Arrays.stream(intArray);
intStream1.forEach(x -> System.out.println(x));
// 2. Stream.of -> Stream<int[]>
Stream<int[]> temp = Stream.of(intArray);
// Cant print Stream<int[]> directly, convert / flat it to IntStream
IntStream intStream2 = temp.flatMapToInt(x -> Arrays.stream(x));
intStream2.forEach(x -> System.out.println(x));
}
}
Output
1 2 3 4 5 1 2 3 4 5
Review the JDK source code.
Arrays.java
/**
* Returns a sequential {@link IntStream} with the specified array as its
* source.
*
* @param array the array, assumed to be unmodified during use
* @return an {@code IntStream} for the array
* @since 1.8
*/
public static IntStream stream(int[] array) {
return stream(array, 0, array.length);
}
Stream.java
/**
* Returns a sequential {@code Stream} containing a single element.
*
* @param t the single element
* @param <T> the type of stream elements
* @return a singleton sequential stream
*/
public static<T> Stream<T> of(T t) {
return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
}
Which one?
For object arrays, both are calling the same
For object arrays, both are calling the same
Arrays.stream (refer example 1, JDK source code). For primitive arrays, I prefer Arrays.stream as well, because it returns fixed size IntStream directly, easier to manipulate it.
P.S Tested with Oracle JDK 1.8.0_77
How can we make this operation null safe?
int[] intArray = null;//{1, 2, 3, 4, 5};
((Stream) (intArray == null ? Stream.empty() : Arrays.stream(intArray))).forEach(System.out::println);
Stream of = (Stream) (intArray == null ? Stream.empty() : Arrays.stream(intArray));
//of.forEach(System.out::println);
of.flatMapToInt(arr -> Arrays.stream(arr)).forEach(System.err::println);
thx 🙂
i also use
IntStream.of(intArray).forEach(System.out::println);
or instead of mapping there’s a “primitive-to-obj” func IntStream.boxed() :
IntStream.of(1,2,3,4,5).boxed().forEach(System.out::println);
I feel it comfortable to sometimes define a Stream as
Stream.of(“A”, “B”,”C”) rather than creating an Array and calling Arrays.stream(thatArray)
However internally it will create an array.
Thanks for sharing