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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    Output:

    44
    33
    22
    11
    


My Personal Notes arrow_drop_up

Just another competitive programmer and hard worker

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.