Home > Java > javaTutorial > body text

How to Efficiently Reverse Streams in Java 8?

Susan Sarandon
Release: 2024-11-01 00:33:28
Original
518 people have browsed it

 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>
Copy after login

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>
Copy after login

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]);
}</code>
Copy after login

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));</code>
Copy after login

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; }));</code>
Copy after login

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!

source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Latest Articles by Author
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
About us Disclaimer Sitemap
php.cn:Public welfare online PHP training,Help PHP learners grow quickly!