Java 8 stream reverse order

Question

General question  What s the proper way to reverse a stream  Assuming that we don t know what type of elements that stream consists of  what s the generic way to reverse any stream   Specific question    IntStream provides range method to generate Integers in specific range IntStream range -range  0   now that I want to reverse it switching range from 0 to negative won t work  also I can t use Integer  compare  List lt Integer gt  list   Arrays asList 1 2 3 4   list stream   sorted Integer  compare  forEach System out  println     with IntStream I ll get this compiler error     Error  191  0  ajc  The method sorted   in the type IntStream is not applicable for the arguments  Integer  compare    what am I missing here

User · Answer

How about reversing the Collection backing the stream prior   import java util Collections  import java util List   public void reverseTest List lt Integer gt  sampleCollection        Collections reverse sampleCollection      remember this reverses the elements in the list  so if you want the original input collection to remain untouched clone it first       sampleCollection stream   forEach item - gt             you op here

User · Answer

How NOT to do it   Don t use  sorted Comparator reverseOrder    or  sorted Collections reverseOrder     because it will just sort elements in the descending order  Using it for given Integer input   1  4  2  5  3  the output would be as follows   5  4  3  2  1  For String input    quot A quot    quot D quot    quot B quot    quot E quot    quot C quot   the output would be as follows   E  D  C  B  A  Don t use  sorted  a  b  - gt  -1   explanation at the end   The easiest way to do it properly  List lt Integer gt  list   Arrays asList 1  4  2  5  3   Collections reverse list   System out println list    Output   3  5  2  4  1  The same for String  List lt String gt  stringList   Arrays asList  quot A quot    quot D quot    quot B quot    quot E quot    quot C quot    Collections reverse stringList   System out println stringList    Output   C  E  B  D  A  Don t use  sorted  a  b  - gt  -1   It breaks comparator contract and might work only for some cases ie  only on single thread but not in parallel  yankee explanation    a  b  - gt  -1 breaks the contract for Comparator  Whether this works depends on the implementation of the sort algorithm  The next release of the JVM might break this  Actually I can already break this reproduciblly on my machine using IntStream range 0  10000  parallel   boxed   sorted  a  b  - gt  -1  forEachOrdered System out  println      Don t use this    List lt Integer gt  list   Arrays asList 1  4  2  5  3   List lt Integer gt  reversedList   list stream            sorted  a  b  - gt  -1           collect Collectors toList     System out println reversedList    Output in positive case   3  5  2  4  1  Possible output in parallel stream or with other JVM implementation   4  1  2  3  5  The same for String    Don t use this    List lt String gt  stringList   Arrays asList  quot A quot    quot D quot    quot B quot    quot E quot    quot C quot    List lt String gt  reversedStringList   stringList stream            sorted  a  b  - gt  -1           collect Collectors toList     System out println reversedStringList    Output in positive case   C  E  B  D  A  Possible output in parallel stream or with other JVM implementation   A  E  B  D  C

User · Answer

Answering specific question of reversing with IntStream  below worked for me   IntStream range 0  10     map x - gt  x   -1     sorted      map Math  abs     forEach System out  println

User · Answer

General Question   Stream does not store any elements   So iterating elements in the reverse order is not possible without storing the elements in some intermediate collection   Stream of  1    2    20    3          collect Collectors toCollection ArrayDeque  new      or LinkedList        descendingIterator          forEachRemaining System out  println     Update  Changed LinkedList to ArrayDeque  better  see here for details  Prints   3  20  2  1   By the way  using sort method is not correct as it sorts  NOT reverses  assuming stream may have unordered elements   Specific Question    I found this simple  easier and intuitive Copied  Holger comment   IntStream iterate to - 1  i - gt  i - 1  limit to - from

User · Answer

This is how I do it   I don t like the idea of creating a new collection and reverse iterating it   The IntStream map idea is pretty neat  but I prefer the IntStream iterate method  for I think the idea of a countdown to Zero better expressed with the iterate method and easier to understand in terms of walking the array from back to front   import static java lang Math max   private static final double EXACT MATCH   0d   public static IntStream reverseStream final int   array        return countdownFrom array length - 1  map index - gt  array index       public static DoubleStream reverseStream final double   array        return countdownFrom array length - 1  mapToDouble index - gt  array index       public static  lt T gt  Stream lt T gt  reverseStream final T   array        return countdownFrom array length - 1  mapToObj index - gt  array index       public static IntStream countdownFrom final int top        return IntStream iterate top  t - gt  t - 1  limit max 0   long  top   1        Here are some tests to prove it works   import static java lang Integer MAX VALUE  import static org junit Assert      Test public void testReverseStream emptyArrayCreatesEmptyStream         Assert assertEquals 0  reverseStream new double 0   count         Test public void testReverseStream singleElementCreatesSingleElementStream         Assert assertEquals 1  reverseStream new double 1   count         final double   singleElementArray   new double     123 4        assertArrayEquals singleElementArray  reverseStream singleElementArray  toArray    EXACT MATCH       Test public void testReverseStream multipleElementsAreStreamedInReversedOrder         final double   arr   new double     1d  2d  3d        final double   revArr   new double     3d  2d  1d        Assert assertEquals arr length  reverseStream arr  count         Assert assertArrayEquals revArr  reverseStream arr  toArray    EXACT MATCH       Test public void testCountdownFrom returnsAllElementsFromTopToZeroInReverseOrder         assertArrayEquals new int     4  3  2  1  0    countdownFrom 4  toArray         Test public void testCountdownFrom countingDownStartingWithZeroOutputsTheNumberZero         assertArrayEquals new int     0    countdownFrom 0  toArray         Test public void testCountdownFrom doesNotChokeOnIntegerMaxValue         assertEquals true  countdownFrom MAX VALUE  anyMatch x - gt  x    MAX VALUE        Test public void testCountdownFrom givesZeroLengthCountForNegativeValues         assertArrayEquals new int 0   countdownFrom -1  toArray         assertArrayEquals new int 0   countdownFrom -4  toArray

User · Answer

With regard to the specific question of generating a reverse IntStream   starting from Java 9 you can use the three-argument version of the IntStream iterate        IntStream iterate 10  x - gt  x  gt   0  x - gt  x - 1  forEach System out  println       Out  10 9 8 7 6 5 4 3 2 1 0   where   IntStream iterate  int seed  IntPredicate hasNext  IntUnaryOperator next     seed - the initial element  hasNext - a predicate to apply to elements to determine when the stream must terminate  next - a function to be applied to the previous element to produce a new element

User · Answer

This method works with any Stream and is Java 8 compliant   Stream lt Integer gt  myStream   Stream of 1  2  3  4  5   myStream reduce Stream empty             Stream lt Integer gt  a  Integer b  - gt  Stream concat Stream of b   a            a  b  - gt  Stream concat b  a            forEach System out  println

User · Answer

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 - gt  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  lt T gt  Stream lt T gt  reverse Stream lt T gt  input        Object   temp   input toArray        return  Stream lt T gt   IntStream range 0  temp length                                   mapToObj i - gt  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 lt T gt  input         List lt T gt  output       input collect ArrayList  new                     list  e  - gt  list add 0  e                      list1  list2  - gt  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 lt String gt  output       input collect Collector of          ArrayDeque  new           deq  t  - gt  deq addFirst t            d1  d2  - gt    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

User · Answer

How about this utility method   public static  lt T gt  Stream lt T gt  getReverseStream List lt T gt  list        final ListIterator lt T gt  listIt   list listIterator list size         final Iterator lt T gt  reverseIterator   new Iterator lt T gt               Override         public boolean hasNext                 return listIt hasPrevious                        Override         public T next                 return listIt previous                         return StreamSupport stream Spliterators spliteratorUnknownSize              reverseIterator              Spliterator ORDERED   Spliterator IMMUTABLE   false       Seems to work with all cases without duplication

User · Answer

Elegant solution   List lt Integer gt  list   Arrays asList 1 2 3 4   list stream        boxed      Converts Intstream to Stream lt Integer gt       sorted Collections reverseOrder       Method on Stream lt Integer gt       forEach System out  println

User · Answer

Based on  stuart-marks s answer  but without casting  function returning stream of list elements starting from end  public static  lt T gt  Stream lt T gt  reversedStream List lt T gt  tList        final int size   tList size        return IntStream range 0  size               mapToObj i - gt  tList get size - 1 - i          usage reversedStream list  forEach System out  println

User · Answer

I would suggest using jOO   it s a great library that adds lots of useful functionality to Java 8 streams and lambdas   You can then do the following   List lt Integer gt  list   Arrays asList 1 2 3 4       Seq seq list  reverse   forEach System out  println    Simple as that  It s a pretty lightweight library  and well worth adding to any Java 8 project

User · Answer

Simplest way  simple collect - supports parallel streams    public static  lt T gt  Stream lt T gt  reverse Stream lt T gt  stream        return stream              collect Collector of                         - gt  new ArrayDeque lt T gt                         ArrayDeque  addFirst                       q1  q2  - gt    q2 addAll q1   return q2                                stream        Advanced way  supports parallel streams in an ongoing way    public static  lt T gt  Stream lt T gt  reverse Stream lt T gt  stream        Objects requireNonNull stream   stream         class ReverseSpliterator implements Spliterator lt T gt            private Spliterator lt T gt  spliterator          private final Deque lt T gt  deque   new ArrayDeque lt  gt              private ReverseSpliterator Spliterator lt T gt  spliterator                this spliterator   spliterator                      Override          SuppressWarnings   StatementWithEmptyBody            public boolean tryAdvance Consumer lt   super T gt  action                while spliterator tryAdvance deque  addFirst                if  deque isEmpty                      action accept deque remove                     return true                            return false                      Override         public Spliterator lt T gt  trySplit                    After traveling started the spliterator don t contain elements              Spliterator lt T gt  prev   spliterator trySplit                if prev    null                    return null                             Spliterator lt T gt  me   spliterator              spliterator   prev              return new ReverseSpliterator me                       Override         public long estimateSize                 return spliterator estimateSize                        Override         public int characteristics                 return spliterator characteristics                        Override         public Comparator lt   super T gt  getComparator                 Comparator lt   super T gt  comparator   spliterator getComparator                return  comparator    null    comparator reversed     null                      Override         public void forEachRemaining Consumer lt   super T gt  action                   Ensure that tryAdvance is called at least once             if  deque isEmpty      tryAdvance action                     deque forEach action                                      return StreamSupport stream new ReverseSpliterator stream spliterator     stream isParallel         Note you can quickly extends to other type of streams  IntStream         Testing      Use parallel if you wish only revert Stream of  One    Two    Three    Four    Five    Six   parallel         forEachOrdered System out  println     Results   Six Five Four Three Two One   Additional notes  The simplest way it isn t so useful when used with other stream operations  the collect join breaks the parallelism   The advance way doesn t have that issue  and it keeps also the initial characteristics of the stream  for example SORTED  and so  it s the way to go to use with other stream operations after the reverse

User · Answer

cyclops-react StreamUtils has a reverse Stream method  javadoc       StreamUtils reverse Stream of  1    2    20    3                  forEach System out  println     It works by collecting to an ArrayList and then making use of the ListIterator class which can iterate in either direction  to iterate backwards over the list    If you already have a List  it will be more efficient    StreamUtils reversedStream Arrays asList  1    2    20    3                  forEach System out  println

User · Answer

List newStream   list stream   sorted Collections reverseOrder    collect Collectors toList             newStream forEach System out  println

User · Answer

Many of the solutions here sort or reverse the IntStream  but that unnecessarily requires intermediate storage  Stuart Marks s solution is the way to go   static IntStream revRange int from  int to        return IntStream range from  to  map i - gt  to - i   from - 1       It correctly handles overflow as well  passing this test    Test public void testRevRange         assertArrayEquals revRange 0  5  toArray    new int   4  3  2  1  0        assertArrayEquals revRange -5  0  toArray    new int   -1  -2  -3  -4  -5        assertArrayEquals revRange 1  4  toArray    new int   3  2  1        assertArrayEquals revRange 0  0  toArray    new int 0        assertArrayEquals revRange 0  -1  toArray    new int 0        assertArrayEquals revRange MIN VALUE  MIN VALUE  toArray    new int 0        assertArrayEquals revRange MAX VALUE  MAX VALUE  toArray    new int 0        assertArrayEquals revRange MIN VALUE  MIN VALUE   1  toArray    new int   MIN VALUE        assertArrayEquals revRange MAX VALUE - 1  MAX VALUE  toArray    new int   MAX VALUE - 1

User · Answer

ArrayDeque are faster in the stack than a Stack or LinkedList   push    inserts elements at the front of the Deque   protected  lt T gt  Stream lt T gt  reverse Stream lt T gt  stream        ArrayDeque lt T gt  stack   new ArrayDeque lt  gt         stream forEach stack  push       return stack stream

User · Answer

without external lib     import java util List  import java util Collections  import java util stream Collector   public class MyCollectors        public static  lt T gt  Collector lt T     List lt T gt  gt  toListReversed             return Collectors collectingAndThen Collectors toList    l - gt                Collections reverse l               return l

User · Answer

Here s the solution I ve come up with   private static final Comparator lt Integer gt  BY ASCENDING ORDER   Integer  compare  private static final Comparator lt Integer gt  BY DESCENDING ORDER   BY ASCENDING ORDER reversed      then using those comparators   IntStream range -range  0  boxed   sorted BY DESCENDING ORDER  forEach    etc

User · Answer

the simplest solution is using List  listIterator and Stream  generate  List lt Integer gt  list   Arrays asList 1  2  3  4  5   ListIterator lt Integer gt  listIterator   list listIterator list size      Stream generate listIterator  previous         limit list size           forEach System out  println

User · Answer

You could define your own collector that collects the elements in reverse order   public static  lt T gt  Collector lt T  List lt T gt   List lt T gt  gt  inReverse         return Collector of          ArrayList  new           l  t  - gt  l add t            l  r  - gt   l addAll r   return l            Lists   lt T gt reverse       And use it like   stream collect inReverse    forEach t - gt         I use an ArrayList in forward order to efficiently insert collect the items  at the end of the list   and Guava Lists reverse to efficiently give a reversed view of the list without making another copy of it   Here are some test cases for the custom collector   import static org hamcrest MatcherAssert assertThat  import static org hamcrest Matchers     import java util ArrayList  import java util List  import java util function BiConsumer  import java util function BinaryOperator  import java util function Function  import java util function Supplier  import java util stream Collector   import org hamcrest Matchers  import org junit Test   import com google common collect Lists   public class TestReverseCollector       private final Object t1   new Object        private final Object t2   new Object        private final Object t3   new Object        private final Object t4   new Object         private final Collector lt Object  List lt Object gt   List lt Object gt  gt  inReverse   inReverse        private final Supplier lt List lt Object gt  gt  supplier   inReverse supplier        private final BiConsumer lt List lt Object gt   Object gt  accumulator   inReverse accumulator        private final Function lt List lt Object gt   List lt Object gt  gt  finisher   inReverse finisher        private final BinaryOperator lt List lt Object gt  gt  combiner   inReverse combiner          Test public void associative             final List lt Object gt  a1   supplier get            accumulator accept a1  t1           accumulator accept a1  t2           final List lt Object gt  r1   finisher apply a1            final List lt Object gt  a2   supplier get            accumulator accept a2  t1           final List lt Object gt  a3   supplier get            accumulator accept a3  t2           final List lt Object gt  r2   finisher apply combiner apply a2  a3             assertThat r1  Matchers equalTo r2                Test public void identity             final List lt Object gt  a1   supplier get            accumulator accept a1  t1           accumulator accept a1  t2           final List lt Object gt  r1   finisher apply a1            final List lt Object gt  a2   supplier get            accumulator accept a2  t1           accumulator accept a2  t2           final List lt Object gt  r2   finisher apply combiner apply a2  supplier get               assertThat r1  equalTo r2                Test public void reversing   throws Exception           final List lt Object gt  a2   supplier get            accumulator accept a2  t1           accumulator accept a2  t2            final List lt Object gt  a3   supplier get            accumulator accept a3  t3           accumulator accept a3  t4            final List lt Object gt  r2   finisher apply combiner apply a2  a3             assertThat r2  contains t4  t3  t2  t1               public static  lt T gt  Collector lt T  List lt T gt   List lt T gt  gt  inReverse             return Collector of              ArrayList  new               l  t  - gt  l add t                l  r  - gt   l addAll r   return l                Lists   lt T gt reverse

User · Answer

For reference I was looking at the same problem  I wanted to join the string value of stream elements in the reverse order   itemList     last  middle  first      first middle last  I started to use an intermediate collection with collectingAndThen from comonad or the ArrayDeque collector of Stuart Marks  although I wasn t happy with intermediate collection  and streaming again  itemList stream            map TheObject  toString           collect Collectors collectingAndThen Collectors toList                                                  strings - gt                                                          Collections reverse strings                                                         return strings                                                             stream            collect Collector joining       So I iterated over Stuart Marks answer that was using the Collector of factory  that has the interesting finisher lambda   itemList stream            collect Collector of StringBuilder  new                                sb  o  - gt  sb insert 0  o                                 r1  r2  - gt    r1 insert 0  r2   return r1                                  StringBuilder  toString      Since in this case the stream is not parallel  the combiner is not relevant that much  I m using insert anyway for the sake of code consistency but it does not matter as it would depend of which stringbuilder is built first   I looked at the StringJoiner  however it does not have an insert method

User · Answer

One could write a collector that collects elements in reversed order   public static  lt T gt  Collector lt T     Stream lt T gt  gt  reversed         return Collectors collectingAndThen Collectors toList    list - gt            Collections reverse list           return list stream                And use it like this   Stream of 1  2  3  4  5  collect reversed    forEach System out  println     Original answer  contains a bug - it does not work correctly for parallel streams    A general purpose stream reverse method could look like   public static  lt T gt  Stream lt T gt  reverse Stream lt T gt  stream        LinkedList lt T gt  stack   new LinkedList lt  gt         stream forEach stack  push       return stack stream

User · Answer

Reversing string or any Array   Stream of  abcdefghijklm 1234567  split      collect Collectors collectingAndThen Collectors toList   list - gt   Collections reverse list  return list      stream   forEach System out  println     split can be modified based on the delimiter or space

User · Answer

The most generic and the easiest way to reverse a list will be    public static  lt T gt  void reverseHelper List lt T gt  li     li stream    sorted  x y - gt  -1   collect Collectors toList     forEach System out  println

User · Answer

If implemented Comparable lt T gt   ex  Integer  String  Date   you can do it using Comparator reverseOrder     List lt Integer gt  list   Arrays asList 1  2  3  4   list stream         sorted Comparator reverseOrder          forEach System out  println

User · Answer

Not purely Java8 but if you use guava s Lists reverse   method in conjunction  you can easily achieve this   List lt Integer gt  list   Arrays asList 1 2 3 4   Lists reverse list  stream   forEach System out  println

User · Answer

Java 8 way to do this       List lt Integer gt  list   Arrays asList 1 2 3 4       Comparator lt Integer gt  comparator   Integer  compare      list stream   sorted comparator reversed    forEach System out  println

User · Answer

In all this I don t see the answer I would go to first   This isn t exactly a direct answer to the question  but it s a potential solution to the problem   Just build the list backwards in the first place   If you can  use a LinkedList instead of an ArrayList and when you add items use  Push  instead of add   The list will be built in the reverse order and will then stream correctly without any manipulation   This won t fit cases where you are dealing with primitive arrays or lists that are already used in various ways but does work well in a surprising number of cases

[java] Java 8 stream reverse order

Examples related to java

Examples related to list

Examples related to sorting

Examples related to java-8

Examples related to java-stream