Java 8 stream reverse order

by

For the specific question of generating a reverse IntStream, try something like this:

static IntStream revRange(int from, int to) {
    return IntStream.range(from, to)
                    .map(i -> to - i + from - 1);
}

This avoids boxing and sorting.

For the general question of how to reverse a stream of any type, I don’t know of there’s a “proper” way. There are a couple ways I can think of. Both end up storing the stream elements. I don’t know of a way to reverse a stream without storing the elements.

This first way stores the elements into an array and reads them out to a stream in reverse order. Note that since we don’t know the runtime type of the stream elements, we can’t type the array properly, requiring an unchecked cast.

@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]);
}

Another technique uses collectors to accumulate the items into a reversed list. This does lots of insertions at the front of ArrayList objects, so there’s lots of copying going on.

Stream<T> input = ... ;
List<T> output =
    input.collect(ArrayList::new,
                  (list, e) -> list.add(0, e),
                  (list1, list2) -> list1.addAll(0, list2));

It’s probably possible to write a much more efficient reversing collector using some kind of customized data structure.

UPDATE 2016-01-29

Since this question has gotten a bit of attention recently, I figure I should update my answer to solve the problem with inserting at the front of ArrayList. This will be horribly inefficient with a large number of elements, requiring O(N^2) copying.

It’s preferable to use an ArrayDeque instead, which efficiently supports insertion at the front. A small wrinkle is that we can’t use the three-arg form of Stream.collect(); it requires the contents of the second arg be merged into the first arg, and there’s no “add-all-at-front” bulk operation on Deque. Instead, we use addAll() to append the contents of the first arg to the end of the second, and then we return the second. This requires using the Collector.of() factory method.

The complete code is this:

Deque<String> output =
    input.collect(Collector.of(
        ArrayDeque::new,
        (deq, t) -> deq.addFirst(t),
        (d1, d2) -> { d2.addAll(d1); return d2; }));

The result is a Deque instead of a List, but that shouldn’t be much of an issue, as it can easily be iterated or streamed in the now-reversed order.

More Related Contents:

  1. Reverse a comparator in Java 8
  2. Sorting a list with stream.sorted() in Java
  3. Nested lists with streams in Java8
  4. Why didn’t Stream have a toList() method?
  5. Group sequences of values
  6. Get last element of Stream/List in a one-liner
  7. In Java, what are the advantages of streams over loops? [closed]
  8. Java 8’s streams: why parallel stream is slower?
  9. Stream and lazy evaluation
  10. Java 8 stream’s .min() and .max(): why does this compile?
  11. Files.walk(), calculate total size
  12. Why does Collections.sort use Mergesort but Arrays.sort does not?
  13. Java List Sorting: Is there a way to keep a list permantly sorted automatically like TreeMap?
  14. How do I create a Stream of regex matches?
  15. Sort map by value using lambdas and streams
  16. Equivalent of Scala dropWhile
  17. Why does Stream.allMatch() return true for an empty stream?
  18. Modifying Objects within stream in Java8 while iterating
  19. Take every nth element from a Java 8 stream
  20. Static context cannot access non-static in Collectors
  21. What Java 8 Stream.collect equivalents are available in the standard Kotlin library?
  22. Java 8, how can I implement a switch statement using streams?
  23. java: Arrays.sort() with lambda expression
  24. In Java 8 how do I transform a Map to another Map using a lambda?
  25. Is it possible to get next element in the Stream?
  26. Does collect operation on Stream close the stream and underlying resources?
  27. How to get multiple values from an object using a single stream operation?
  28. non-interference requirement on Java 8 streams
  29. Java 8 Stream and operation on arrays
  30. What is the difference between intermediate and terminal operations?

Leave a Comment