How to Efficiently Reverse Streams in Java 8?

Exploring Stream Reversal Techniques in Java 8

When dealing with streams in Java 8, encountering the need to reverse their order is not uncommon. To ascertain the correct approach for reversing any stream, we delve into the specific challenge of reversing an IntStream while exploring additional solutions for reversing streams of any type.

IntStream Reversal:*

IntStream offers a range() method for generating integers within a specified range. To reverse the range, simply adjust the arguments:

<code class="java">IntStream.range(-range, 0)</code>

However, this approach is impractical, and Integer::compare cannot be used due to compiler errors. Instead, consider the following code:

<code class="java">static IntStream revRange(int from, int to) {
    return IntStream.range(from, to)
                    .map(i -> to - i + from - 1);
}</code>

This method reverses the range without boxing or sorting.

General Stream Reversal:

There are multiple ways to reverse streams of any type, but both require storing the elements.

Array Based Reversal:

This method uses an array to store elements for subsequent reading in reverse order:

<code class="java">@SuppressWarnings("unchecked")
static <t> Stream<t> reverse(Stream<t> input) {
    Object[] temp = input.toArray();
    return (Stream<t>) IntStream.range(0, temp.length)
                                .mapToObj(i -> temp[temp.length - i - 1]);
}</t></t></t></t></code>

Collector Based Reversal:

Collectors can be used to accumulate elements into a reversed list:

<code class="java">Stream<t> input = ... ;
List<t> output =
    input.collect(ArrayList::new,
                  (list, e) -> list.add(0, e),
                  (list1, list2) -> list1.addAll(0, list2));</t></t></code>

While this is effective, it triggers many ArrayList.add(0, ...) insertions, resulting in excessive copying.

Efficient Collector Based Reversal:

To mitigate the drawback of copying, consider using an ArrayDeque, which supports efficient insertions at the front:

<code class="java">Deque<string> output =
    input.collect(Collector.of(
        ArrayDeque::new,
        (deq, t) -> deq.addFirst(t),
        (d1, d2) -> { d2.addAll(d1); return d2; }));</string></code>

This updated code maintains the efficiency of the Collector based reversal while eliminating unnecessary copying.

The above is the detailed content of How to Efficiently Reverse Streams in Java 8?. For more information, please follow other related articles on the PHP Chinese website!