Reverse elements of a Parallel Stream in Java
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:
- 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:
import java.util.*;
import java.util.stream.*;
class GFG {
public static <T> Collector<T, ?, Stream<T> > reverseStream()
{
return Collectors
.collectingAndThen(Collectors.toList(),
list -> {
Collections.reverse(list);
return list.stream();
});
}
public static void main(String[] args)
{
List<Integer> lists = Arrays.asList( 11 , 22 , 33 , 44 );
Stream<Integer> stream = lists.parallelStream();
stream.collect(reverseStream())
.forEach(System.out::println);
}
}
|
- 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:
import java.util.*;
import java.util.stream.*;
class GFG {
public static <T> Iterator<T> reverseStream(Stream<T> stream)
{
return stream
.collect(Collectors
.toCollection(LinkedList:: new ))
.descendingIterator();
}
public static void main(String[] args)
{
List<Integer> lists = Arrays.asList( 11 , 22 , 33 , 44 );
Stream<Integer> stream = lists.parallelStream();
Iterator<Integer> reverse = reverseStream(stream);
reverse.forEachRemaining(System.out::println);
}
}
|
- 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:
- 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:
import java.util.*;
import java.util.stream.*;
class GFG {
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();
}
public static void main(String[] args)
{
List<Integer> lists = Arrays.asList( 11 , 22 , 33 , 44 );
Stream<Integer> stream = lists.parallelStream();
reverseStream(stream)
.forEach(System.out::println);
}
}
|
Share your thoughts in the comments
Please Login to comment...