Skip to content
Related Articles

Related Articles

Improve Article

Reverse elements of a Parallel Stream in Java

  • Difficulty Level : Expert
  • Last Updated : 11 Dec, 2018

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 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 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 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);
        }
    }
    Output:
    44
    33
    22
    11
    

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :