Difference between Stream.of() and Arrays.stream() method in Java - GeeksforGeeks

11 Dec, 2018
The stream(T[] array) method of Arrays class in Java, is used to get a Sequential Stream from the array passed as the parameter with its elements. It returns a sequential Stream with the elements of the array, passed as parameter, as its source.
Example:
// Java program to demonstrate Arrays.stream() method  import java.util.*;import java.util.stream.*;  class GFG {    public static void main(String[] args)    {          // Creating a String array        String[] arr = { "Geeks", "for", "Geeks" };          // Using Arrays.stream() to convert        // array into Stream        Stream<String> stream = Arrays.stream(arr);          // Displaying elements in Stream        stream.forEach(str -> System.out.print(str + " "));    }}
The Stream of(T... values) returns a sequential ordered stream whose elements are the specified values. Stream.of() method simply calls the Arrays.stream() method for non-primitive types.
Example:
// Java code for Stream of(T... values)// to get a sequential ordered stream whose// elements are the specified values.  import java.util.*;import java.util.stream.Stream;  class GFG {      // Driver code    public static void main(String[] args)    {        // Creating an Stream        Stream stream = Stream.of("Geeks", "for", "Geeks");          // Displaying the sequential ordered stream        stream.forEach(str -> System.out.print(str + " "));    }}
These both methods are the two most commonly used methods for creating a sequential stream from a specified array. Both these methods returns a Stream<T> when called with a non-primitive type T.
Difference between Arrays.stream() and Stream.of()
Even if Stream.of() is a wrapper over the Arrays.stream() method, there are certain point of differences which clearifies as when to use a Arrays.stream() or when to use Stream.of(). Below are some of the differences between the above two stated methods:
Different return types:For primitives arrays (like int[], long[] etc), Arrays.stream() and Stream.of() have different return types.Example: Passing an integer array, the Stream.of() method returns Stream whereas Arrays.stream() returns an IntStream.// Java program to demonstrate return type// of Arrays.stream() and Stream.of() method// for primitive arrays  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating an integer array        int arr[] = { 1, 2, 3, 4, 5 };          // --------- Using Arrays.stream() ---------          // to convert int array into Stream        IntStream intStream = Arrays.stream(arr);          // Displaying elements in Stream        intStream.forEach(str -> System.out.print(str + " "));          // --------- Using Stream.of() ---------          // to convert int array into Stream        Stream<int[]> stream = Stream.of(arr);          // Displaying elements in Stream        stream.forEach(str -> System.out.print(str + " "));    }}Stream.of() needs flattening whereas Arrays.stream() does not:As the ideal class used for processing of Streams of primitive types are their primitive Stream types (like IntStream, LongStream, etc). Therefore Stream.of() needs to be explicitly flattened into its primitive Stream before consuming.Example:// Java program to demonstrate need of flattenning// Stream.of() method returned type for primitive arrays  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating an integer array        int arr[] = { 1, 2, 3, 4, 5 };          // --------- Using Arrays.stream() ---------          // to convert int array into Stream        IntStream intStream = Arrays.stream(arr);          // Displaying elements in Stream        intStream.forEach(str -> System.out.print(str + " "));          // --------- Using Stream.of() ---------          // to convert int array into Stream        Stream<int[]> stream = Stream.of(arr);          // ***** Flattening of Stream<int[]> into IntStream *****          // flattenning Stream<int[]> into IntStream        // using flatMapToInt()        IntStream intStreamNew = stream.flatMapToInt(Arrays::stream);          // Displaying elements in IntStream        intStreamNew.forEach(str -> System.out.print(str + " "));    }}Stream.of() is generic whereas Arrays.stream is not:Arrays.stream() method only works for primitive arrays of int[], long[], and double[] type, and returns IntStream, LongStream and DoubleStream respectively. For other primitive types, Arrays.stream() won’t work.On the other hand, Stream.of() returns a generic Stream of type T (Stream). Hence, it can be used with any type.Example:For Arrays.stream() method:// Java program to demonstrate return type// of Arrays.stream() method// for primitive arrays of char  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating a character array        char arr[] = { '1', '2', '3', '4', '5' };          // --------- Using Arrays.stream() ---------        // This will throw error          // to convert char array into Stream        Arrays.stream(arr);    }}Output:Compilation Error in java code :-prog.java:20: error: no suitable method found for stream(char[])Arrays.stream(arr);^For Stream.of() method:// Java program to demonstrate return type// of Stream.of() method// for primitive arrays of char  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating a character array        char arr[] = { '1', '2', '3', '4', '5' };          // --------- Using Stream.of() ---------        // Will work efficiently          // to convert int array into Stream        Stream<char[]> stream = Stream.of(arr);          // Displaying elements in Stream        stream.forEach(str -> System.out.print(str + " "));    }}
Different return types:For primitives arrays (like int[], long[] etc), Arrays.stream() and Stream.of() have different return types.Example: Passing an integer array, the Stream.of() method returns Stream whereas Arrays.stream() returns an IntStream.// Java program to demonstrate return type// of Arrays.stream() and Stream.of() method// for primitive arrays  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating an integer array        int arr[] = { 1, 2, 3, 4, 5 };          // --------- Using Arrays.stream() ---------          // to convert int array into Stream        IntStream intStream = Arrays.stream(arr);          // Displaying elements in Stream        intStream.forEach(str -> System.out.print(str + " "));          // --------- Using Stream.of() ---------          // to convert int array into Stream        Stream<int[]> stream = Stream.of(arr);          // Displaying elements in Stream        stream.forEach(str -> System.out.print(str + " "));    }}
For primitives arrays (like int[], long[] etc), Arrays.stream() and Stream.of() have different return types.
Example: Passing an integer array, the Stream.of() method returns Stream whereas Arrays.stream() returns an IntStream.
// Java program to demonstrate return type// of Arrays.stream() and Stream.of() method// for primitive arrays  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating an integer array        int arr[] = { 1, 2, 3, 4, 5 };          // --------- Using Arrays.stream() ---------          // to convert int array into Stream        IntStream intStream = Arrays.stream(arr);          // Displaying elements in Stream        intStream.forEach(str -> System.out.print(str + " "));          // --------- Using Stream.of() ---------          // to convert int array into Stream        Stream<int[]> stream = Stream.of(arr);          // Displaying elements in Stream        stream.forEach(str -> System.out.print(str + " "));    }}
Stream.of() needs flattening whereas Arrays.stream() does not:As the ideal class used for processing of Streams of primitive types are their primitive Stream types (like IntStream, LongStream, etc). Therefore Stream.of() needs to be explicitly flattened into its primitive Stream before consuming.Example:// Java program to demonstrate need of flattenning// Stream.of() method returned type for primitive arrays  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating an integer array        int arr[] = { 1, 2, 3, 4, 5 };          // --------- Using Arrays.stream() ---------          // to convert int array into Stream        IntStream intStream = Arrays.stream(arr);          // Displaying elements in Stream        intStream.forEach(str -> System.out.print(str + " "));          // --------- Using Stream.of() ---------          // to convert int array into Stream        Stream<int[]> stream = Stream.of(arr);          // ***** Flattening of Stream<int[]> into IntStream *****          // flattenning Stream<int[]> into IntStream        // using flatMapToInt()        IntStream intStreamNew = stream.flatMapToInt(Arrays::stream);          // Displaying elements in IntStream        intStreamNew.forEach(str -> System.out.print(str + " "));    }}
As the ideal class used for processing of Streams of primitive types are their primitive Stream types (like IntStream, LongStream, etc). Therefore Stream.of() needs to be explicitly flattened into its primitive Stream before consuming.
Example:
// Java program to demonstrate need of flattenning// Stream.of() method returned type for primitive arrays  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating an integer array        int arr[] = { 1, 2, 3, 4, 5 };          // --------- Using Arrays.stream() ---------          // to convert int array into Stream        IntStream intStream = Arrays.stream(arr);          // Displaying elements in Stream        intStream.forEach(str -> System.out.print(str + " "));          // --------- Using Stream.of() ---------          // to convert int array into Stream        Stream<int[]> stream = Stream.of(arr);          // ***** Flattening of Stream<int[]> into IntStream *****          // flattenning Stream<int[]> into IntStream        // using flatMapToInt()        IntStream intStreamNew = stream.flatMapToInt(Arrays::stream);          // Displaying elements in IntStream        intStreamNew.forEach(str -> System.out.print(str + " "));    }}
Stream.of() is generic whereas Arrays.stream is not:Arrays.stream() method only works for primitive arrays of int[], long[], and double[] type, and returns IntStream, LongStream and DoubleStream respectively. For other primitive types, Arrays.stream() won’t work.On the other hand, Stream.of() returns a generic Stream of type T (Stream). Hence, it can be used with any type.Example:For Arrays.stream() method:// Java program to demonstrate return type// of Arrays.stream() method// for primitive arrays of char  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating a character array        char arr[] = { '1', '2', '3', '4', '5' };          // --------- Using Arrays.stream() ---------        // This will throw error          // to convert char array into Stream        Arrays.stream(arr);    }}Output:Compilation Error in java code :-prog.java:20: error: no suitable method found for stream(char[])Arrays.stream(arr);^For Stream.of() method:// Java program to demonstrate return type// of Stream.of() method// for primitive arrays of char  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating a character array        char arr[] = { '1', '2', '3', '4', '5' };          // --------- Using Stream.of() ---------        // Will work efficiently          // to convert int array into Stream        Stream<char[]> stream = Stream.of(arr);          // Displaying elements in Stream        stream.forEach(str -> System.out.print(str + " "));    }}
Arrays.stream() method only works for primitive arrays of int[], long[], and double[] type, and returns IntStream, LongStream and DoubleStream respectively. For other primitive types, Arrays.stream() won’t work.On the other hand, Stream.of() returns a generic Stream of type T (Stream). Hence, it can be used with any type.
Example:
For Arrays.stream() method:// Java program to demonstrate return type// of Arrays.stream() method// for primitive arrays of char  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating a character array        char arr[] = { '1', '2', '3', '4', '5' };          // --------- Using Arrays.stream() ---------        // This will throw error          // to convert char array into Stream        Arrays.stream(arr);    }}Output:Compilation Error in java code :-prog.java:20: error: no suitable method found for stream(char[])Arrays.stream(arr);^
// Java program to demonstrate return type// of Arrays.stream() method// for primitive arrays of char  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating a character array        char arr[] = { '1', '2', '3', '4', '5' };          // --------- Using Arrays.stream() ---------        // This will throw error          // to convert char array into Stream        Arrays.stream(arr);    }}
Output:
Compilation Error in java code :-prog.java:20: error: no suitable method found for stream(char[])Arrays.stream(arr);^
For Stream.of() method:// Java program to demonstrate return type// of Stream.of() method// for primitive arrays of char  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating a character array        char arr[] = { '1', '2', '3', '4', '5' };          // --------- Using Stream.of() ---------        // Will work efficiently          // to convert int array into Stream        Stream<char[]> stream = Stream.of(arr);          // Displaying elements in Stream        stream.forEach(str -> System.out.print(str + " "));    }}
// Java program to demonstrate return type// of Stream.of() method// for primitive arrays of char  import java.util.*;import java.util.stream.*;  class GFG {      public static void main(String[] args)    {        // Creating a character array        char arr[] = { '1', '2', '3', '4', '5' };          // --------- Using Stream.of() ---------        // Will work efficiently          // to convert int array into Stream        Stream<char[]> stream = Stream.of(arr);          // Displaying elements in Stream        stream.forEach(str -> System.out.print(str + " "));    }}
Java-Array-Programs
Java-Arrays
Java-Functions
java-stream
Java-Stream-programs
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Object Oriented Programming (OOPs) Concept in Java
HashMap in Java with Examples
Interfaces in Java
How to iterate any Map in Java
ArrayList in Java
Initialize an ArrayList in Java
Stack Class in Java
Multidimensional Arrays in Java
Singleton Class in Java
Set in Java