Skip to content
Related Articles

Related Articles

Reverse elements of a Parallel Stream in Java

Improve Article
Save Article
  • Difficulty Level : Expert
  • Last Updated : 11 Dec, 2018
Improve Article
Save Article

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
    

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!