Elementos inversos de un flujo paralelo en Java

Dado un flujo paralelo en Java, la tarea es invertir sus elementos.

Ejemplos:

Input: Parallel Stream = {11, 22, 33, 44}
Output: {44, 33, 22, 11}

Input: Parallel Stream = {a, b, c, d}
Output: {d, c, b, a}

A continuación se muestran las diversas formas de hacerlo:

1. Uso de la clase Collectors : dado que las secuencias en Java no almacenan ningún elemento, se utiliza una colección intermedia para crear una nueva secuencia con la ayuda de la clase Collectors.
   Algoritmo:
   1. Obtener la secuencia paralela.
   2. Convierta la secuencia en una lista utilizando el método Collectors.toList().
   3. Para esta lista, invierta sus elementos usando el método Collections.reverse().
   4. Convierta esta lista invertida en flujo usando el método List.stream().
   5. Devolver/Imprimir esta secuencia con los elementos invertidos.

   A continuación se muestra la implementación del enfoque anterior:

   Programa:

   // Java program to reverse elements // of a parallel Stream    import java.util.*; import java.util.stream.*;    class GFG {        // Generic function to reverse     // the elements of the parallel stream     public static <T> Collector<T, ?, Stream<T> > reverseStream()     {         return Collectors             .collectingAndThen(Collectors.toList(),                                list -> {                                    Collections.reverse(list);                                    return list.stream();                                });     }        // Driver code     public static void main(String[] args)     {            // Get the parallel stream         List<Integer> lists = Arrays.asList(11, 22, 33, 44);         Stream<Integer> stream = lists.parallelStream();            // Reverse and print the elements         stream.collect(reverseStream())             .forEach(System.out::println);     } }

   Producción:

   44
   33
   22
   11
   

2. Uso de la clase LinkedList : la clase LinkedList implementa la interfaz List y tiene una característica llamada Stack. Entonces LinkedList admite la inserción en la parte delantera. Aprovechando esto, se puede crear una LinkedList a partir de elementos de la secuencia especificada y devolverle un iterador descendente. Esto invertiría los elementos de la corriente paralela.

   Algoritmo:

   1. Obtener la secuencia paralela.
   2. Convierta la secuencia en LinkedList usando el método Collectors.toCollection().
   3. Para esta LinkedList, devuelva el iterador descendente usando el método descendingIterator().
   4. Devuelve/imprime este iterador con los elementos invertidos.

   A continuación se muestra la implementación del enfoque anterior:

   Programa:

   // Java program to reverse elements // of a parallel Stream    import java.util.*; import java.util.stream.*;    class GFG {        // Generic function to reverse     // the elements of the parallel stream     public static <T> Iterator<T> reverseStream(Stream<T> stream)     {         return stream             .collect(Collectors                          .toCollection(LinkedList::new))             .descendingIterator();     }        // Driver code     public static void main(String[] args)     {            // Get the parallel stream         List<Integer> lists = Arrays.asList(11, 22, 33, 44);         Stream<Integer> stream = lists.parallelStream();            // Reverse and print the elements         Iterator<Integer> reverse = reverseStream(stream);         reverse.forEachRemaining(System.out::println);     } }

   Producción:

   44
   33
   22
   11
   

3. Collector.of() : la idea es crear un colector que acumule elementos del Stream especificado en un ArrayDeque o ArrayList en orden inverso

   Algoritmo:

   1. Obtener la secuencia paralela.
   2. Convierta la secuencia en Colección utilizando el método Collectors.of().
   3. En esta colección, agregue los elementos en orden inverso
   4. Convierta esta colección invertida en flujo mediante el método Collection.stream().
   5. Devolver/Imprimir esta secuencia con los elementos invertidos.

   A continuación se muestra la implementación del enfoque anterior:

   Programa:

   // Java program to reverse elements // of a parallel Stream    import java.util.*; import java.util.stream.*;    class GFG {        // Generic function to reverse     // the elements of the parallel stream     public static <T> Stream<T> reverseStream(Stream<T> stream)     {         return stream             .collect(                 Collector.of(                     () -> new ArrayDeque<T>(), ArrayDeque::addFirst, (a, b) -> {                         b.addAll(a);                         return b;                     }))             .stream();     }        // Driver code     public static void main(String[] args)     {            // Get the parallel stream         List<Integer> lists = Arrays.asList(11, 22, 33, 44);         Stream<Integer> stream = lists.parallelStream();            // Reverse and print the elements         reverseStream(stream)             .forEach(System.out::println);     } }

   Producción:

   44
   33
   22
   11