Diferencia entre el método Stream.of() y Arrays.stream() en Java

Arreglos.stream()

El método stream(T[] array) de la clase Arrays en Java , se utiliza para obtener un Sequential Stream del array pasado como parámetro con sus elementos. Devuelve un Stream secuencial con los elementos del array, pasados ​​como parámetro, como su fuente.

Ejemplo:

// 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 + " "));
    }
}

Corriente de()

El flujo de (valores T…) devuelve un flujo ordenado secuencial cuyos elementos son los valores especificados. El método Stream.of() simplemente llama al método Arrays.stream() para tipos no primitivos.

Ejemplo:

// 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 + " "));
    }
}

Estos dos métodos son los dos métodos más utilizados para crear un flujo secuencial a partir de una array específica. Ambos métodos devuelven un Stream<T> cuando se les llama con un tipo T no primitivo.

Diferencia entre Arrays.stream() y Stream.of()

Incluso si Stream.of() es un envoltorio sobre el método Arrays.stream(), hay ciertos puntos de diferencias que aclaran cuándo usar Arrays.stream() o cuándo usar Stream.of(). A continuación se muestran algunas de las diferencias entre los dos métodos indicados anteriormente:

1. Diferentes tipos de devolución :

   Para arrays primitivas (como int[], long[], etc.), Arrays.stream() y Stream.of() tienen diferentes tipos de devolución.

   Ejemplo: al pasar una array de enteros, el método Stream.of() devuelve Streammientras que Arrays.stream() devuelve un 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 + " "));     } }

2. Stream.of() necesita aplanarse mientras que Arrays.stream() no :

   Como la clase ideal utilizada para el procesamiento de Streams de tipos primitivos son sus tipos de Stream primitivos (como IntStream, LongStream, etc.). Por lo tanto, Stream.of() debe aplanarse explícitamente en su Stream primitivo antes de consumir.

   Ejemplo:

   // 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 + " "));     } }

3. Stream.of() es genérico mientras que Arrays.stream no lo es :

   El método Arrays.stream() solo funciona para arrays primitivas de tipo int[], long[] y double[], y devuelve IntStream, LongStream y DoubleStream respectivamente. Para otros tipos primitivos, Arrays.stream() no funcionará.
   Por otro lado, Stream.of() devuelve un Stream genérico de tipo T (Stream). Por lo tanto, se puede utilizar con cualquier tipo.

   Ejemplo:

   • Para el método Arrays.stream():

     // 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);     } }

     Producción:

     Error de compilación en código java: –
     prog.java:20: error: no se encontró un método adecuado para stream(char[])
     Arrays.stream(arr);
     ^

   • Para el método Stream.of():

     // 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 + " "));     } }