Reverse elements of a Parallel Stream in Java

Given a Parallel Stream in Java, the task is to reverse its elements. Examples:

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

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

Below are the various ways to do so:

1. Using Collectors class : Since Streams in Java don't store any elements, therefore, an intermediate collection is used for creating a new stream with the help of Collectors Class. Algorithm:
   1. Get the parallel stream.
   2. Convert the stream to list using Collectors.toList() method.
   3. For this list, reverse its elements using Collections.reverse() method.
   4. Convert this reversed list to stream using List.stream() method.
   5. Return/Print this stream with elements reversed.
   Below is the implementation of the above approach: Program: JAVA

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

   Output:

   44
   33
   22
   11
   

2. Using LinkedList class : LinkedList class implements List interface and has a feature called Stack. So LinkedList supports insertion at the front. Taking advantage of this, a LinkedList can be created from elements of the specified stream and return descending iterator to it. This would reverse the elements of the parallel stream. Algorithm:
   1. Get the parallel stream.
   2. Convert the stream to LinkedList using Collectors.toCollection() method.
   3. For this LinkedList, return the descending iterator using descendingIterator() method.
   4. Return/Print this iterator with elements reversed.
   Below is the implementation of the above approach: Program: JAVA

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

   Output:

   44
   33
   22
   11
   

3. Collector.of() : The idea is to create a collector that accumulates elements of the specified Stream into an ArrayDeque or ArrayList in reverse order Algorithm:
   1. Get the parallel stream.
   2. Convert the stream to Collection using Collectors.of() method.
   3. In this collection, add the elements in reverse order
   4. Convert this reversed collection to stream using Collection.stream() method.
   5. Return/Print this stream with elements reversed.
   Below is the implementation of the above approach: Program: JAVA

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