Reverse elements of a Parallel Stream in Java - GeeksforGeeks

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:
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:Get the parallel stream.Convert the stream to list using Collectors.toList() method.For this list, reverse its elements using Collections.reverse() method.Convert this reversed list to stream using List.stream() method.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
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:Get the parallel stream.Convert the stream to LinkedList using Collectors.toCollection() method.For this LinkedList, return the descending iterator using descendingIterator() method.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
Collector.of() : The idea is to create a collector that accumulates elements of the specified Stream into an ArrayDeque or ArrayList in reverse orderAlgorithm:Get the parallel stream.Convert the stream to Collection using Collectors.of() method.In this collection, add the elements in reverse orderConvert this reversed collection to stream using Collection.stream() method.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

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:Get the parallel stream.Convert the stream to list using Collectors.toList() method.For this list, reverse its elements using Collections.reverse() method.Convert this reversed list to stream using List.stream() method.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

Get the parallel stream.Convert the stream to list using Collectors.toList() method.For this list, reverse its elements using Collections.reverse() method.Convert this reversed list to stream using List.stream() method.Return/Print this stream with elements reversed.
Get the parallel stream.
Convert the stream to list using Collectors.toList() method.
For this list, reverse its elements using Collections.reverse() method.
Convert this reversed list to stream using List.stream() method.
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);    }}
44
33
22
11

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:Get the parallel stream.Convert the stream to LinkedList using Collectors.toCollection() method.For this LinkedList, return the descending iterator using descendingIterator() method.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

Algorithm:
Get the parallel stream.Convert the stream to LinkedList using Collectors.toCollection() method.For this LinkedList, return the descending iterator using descendingIterator() method.Return/Print this iterator with elements reversed.
Get the parallel stream.
Convert the stream to LinkedList using Collectors.toCollection() method.
For this LinkedList, return the descending iterator using descendingIterator() method.
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);    }}
44
33
22
11

Collector.of() : The idea is to create a collector that accumulates elements of the specified Stream into an ArrayDeque or ArrayList in reverse orderAlgorithm:Get the parallel stream.Convert the stream to Collection using Collectors.of() method.In this collection, add the elements in reverse orderConvert this reversed collection to stream using Collection.stream() method.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

Algorithm:
Get the parallel stream.Convert the stream to Collection using Collectors.of() method.In this collection, add the elements in reverse orderConvert this reversed collection to stream using Collection.stream() method.Return/Print this stream with elements reversed.
Get the parallel stream.
Convert the stream to Collection using Collectors.of() method.
In this collection, add the elements in reverse order
Convert this reversed collection to stream using Collection.stream() method.
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);    }}
44
33
22
11

Java - util package
Java-Collections
Java-Stream-Collectors
Java-Stream-programs
Picked
Technical Scripter 2018
Java
Technical Scripter
Java
Java-Collections
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Functional Interfaces in Java
Stream In Java
Constructors in Java
Different ways of Reading a text file in Java
Exceptions in Java
Generics in Java
Comparator Interface in Java with Examples
Strings in Java
How to remove an element from ArrayList in Java?
Difference between Abstract Class and Interface in Java