一般问题：如何正确地反转一个流？假设我们不知道这个流包含什么类型的元素，有什么通用方法可以反转任何流？
具体问题：
IntStream提供了range方法来在特定范围内生成整数IntStream.range（-range，0），现在我想将其反转，从0到负数的切换范围行不通，也无法使用Integer::compare。
List<Integer> list = Arrays.asList(1,2,3,4);
list.stream().sorted(Integer::compare).forEach(System.out::println);
使用 IntStream 我会得到以下编译错误：
Error:(191, 0) ajc: The method
sorted()in the typeIntStreamis not applicable for the arguments (Integer::compare)
我错过了什么？
针对生成反向IntStream的具体问题，可以尝试以下代码：
static IntStream revRange(int from, int to) {
return IntStream.range(from, to)
.map(i -> to - i + from - 1);
}
@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]);
}
另一种技术使用收集器将项目累积到反向列表中。这会在ArrayList对象的前面进行大量插入，因此会进行大量复制。
Stream<T> input = ... ;
List<T> output =
input.collect(ArrayList::new,
(list, e) -> list.add(0, e),
(list1, list2) -> list1.addAll(0, list2));
使用某种定制的数据结构，可能可以编写更高效的反转收集器。
更新 2016-01-29
由于这个问题最近引起了一些关注，我认为我应该更新我的答案来解决在 ArrayList 前插入的问题。这会非常低效，需要 O(N^2) 的复制。
更好的选择是使用 ArrayDeque，它能够有效地支持在前面插入元素。一个小问题是，我们不能使用 Stream.collect() 的三个参数形式；它需要将第二个参数的内容合并到第一个参数中，而 Deque 上没有 "添加所有到前面" 的批量操作。相反，我们使用 addAll() 将第一个参数的内容附加到第二个参数的末尾，然后返回第二个参数。这需要使用 Collector.of() 工厂方法。
完整代码如下：
Deque<String> output =
input.collect(Collector.of(
ArrayDeque::new,
(deq, t) -> deq.addFirst(t),
(d1, d2) -> { d2.addAll(d1); return d2; }));
Deque而不是List，但这并不是什么大问题，因为可以很容易地迭代或流式处理现在的反向顺序。IntStream.iterate(to-1, i->i-1).limit(to-from)。 - Holger.limit(endExcl-(long)startIncl)，但对于如此大的流，这种做法是不推荐的，因为它比基于range的解决方案效率低得多。当我写下这条评论时，我还不知道这种效率差异。 - Holger优雅的解决方案
List<Integer> list = Arrays.asList(1,2,3,4);
list.stream()
.sorted(Collections.reverseOrder()) // Method on Stream<Integer>
.forEach(System.out::println);
通用问题：
流不存储任何元素。
因此，如果没有在某个中间集合中存储元素，则无法按相反的顺序迭代元素。
Stream.of("1", "2", "20", "3")
.collect(Collectors.toCollection(ArrayDeque::new)) // or LinkedList
.descendingIterator()
.forEachRemaining(System.out::println);
更新：将LinkedList更改为ArrayDeque（更好）详情请参见此处
输出：
3
20
2
1
顺便说一下，使用sort方法是不正确的，因为它排序而不是翻转（假设流可能具有无序元素）
具体问题：
我发现这个方法简单、容易理解（复制自@Holger的评论）
IntStream.iterate(to - 1, i -> i - 1).limit(to - from)
这里许多解决方案都对 IntStream 进行排序或反转，但这样会不必要地需要中间存储。 Stuart Marks 的解决方案 才是正确的：
static IntStream revRange(int from, int to) {
return IntStream.range(from, to).map(i -> to - i + from - 1);
}
它也能正确地处理溢出，通过了这个测试：
@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});
}
如何不要做：
.sorted(Comparator.reverseOrder())或.sorted(Collections.reverseOrder())，因为它只会按降序排序元素。[1, 4, 2, 5, 3][5, 4, 3, 2, 1]["A", "D", "B", "E", "C"][E, D, C, B, A].sorted((a, b) -> -1)（解释在结尾处）正确的最简单方法：
List<Integer> list = Arrays.asList(1, 4, 2, 5, 3);
Collections.reverse(list);
System.out.println(list);
输出：
[3, 5, 2, 4, 1]
对于String也是同样的操作：
List<String> stringList = Arrays.asList("A", "D", "B", "E", "C");
Collections.reverse(stringList);
System.out.println(stringList);
输出：
[C, E, B, D, A]
不要使用 .sorted((a, b) -> -1)！
这会破坏比较器的合同，并且可能仅适用于某些情况，例如仅在单线程中而不是并行中。
简单解释：
(a, b) -> -1违反了Comparator的合同。这是否有效取决于排序算法的实现。JVM 的下一个版本可能会破坏此功能。实际上，我可以使用IntStream.range(0, 10000).parallel().boxed().sorted((a, b) -> -1).forEachOrdered(System.out::println);在我的计算机上可重现地破坏它。
//Don't use this!!!
List<Integer> list = Arrays.asList(1, 4, 2, 5, 3);
List<Integer> reversedList = list.stream()
.sorted((a, b) -> -1)
.collect(Collectors.toList());
System.out.println(reversedList);
正常情况下的输出结果为：
[3, 5, 2, 4, 1]
在并行流或其他JVM实现中可能会出现以下输出结果：
[4, 1, 2, 3, 5]
String类型同理：
//Don't use this!!!
List<String> stringList = Arrays.asList("A", "D", "B", "E", "C");
List<String> reversedStringList = stringList.stream()
.sorted((a, b) -> -1)
.collect(Collectors.toList());
System.out.println(reversedStringList);
正常情况下的输出结果为：
[C, E, B, D, A]
在并行流或其他JVM实现中，可能的输出结果为：
[A, E, B, D, C]
(a, b) -> -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) -> -1).forEachOrdered(System.out::println); - yankee.parallel()，也不能依赖它，因为您不知道虚拟机将如何运行它，也不知道将使用哪个排序算法（甚至单线程工作的排序算法可能会在此实现中出现问题）。谢谢您的评论。我会在空闲时间里修改我的答案。 - luke没有使用外部库...
import java.util.List;
import java.util.Collections;
import java.util.stream.Collector;
public class MyCollectors {
public static <T> Collector<T, ?, List<T>> toListReversed() {
return Collectors.collectingAndThen(Collectors.toList(), l -> {
Collections.reverse(l);
return l;
});
}
}
Collectors.toList() 明确不保证生成的列表是可变的，而 Collections.reverse 需要改变列表才能生效。 "返回的列表的可变性没有任何保证；如果需要更多对返回列表的控制，请使用 toCollection(Supplier)。" Collections.toCollection(ArrayList::new) 可以保证工作，而 toList 只是在当前 Java 库的实现中偶然起作用。 - M. Justinpublic static <T> Collector<T, List<T>, List<T>> inReverse() {
return Collector.of(
ArrayList::new,
(l, t) -> l.add(t),
(l, r) -> {l.addAll(r); return l;},
Lists::<T>reverse);
}
并且像这样使用：
stream.collect(inReverse()).forEach(t -> ...)
我使用ArrayList按顺序高效地插入收集项目（在列表末尾），并使用Guava Lists.reverse高效地提供列表的反向视图而不制作另一个副本。
这里是自定义收集器的一些测试用例：
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<Object, List<Object>, List<Object>> inReverse = inReverse();
private final Supplier<List<Object>> supplier = inReverse.supplier();
private final BiConsumer<List<Object>, Object> accumulator = inReverse.accumulator();
private final Function<List<Object>, List<Object>> finisher = inReverse.finisher();
private final BinaryOperator<List<Object>> combiner = inReverse.combiner();
@Test public void associative() {
final List<Object> a1 = supplier.get();
accumulator.accept(a1, t1);
accumulator.accept(a1, t2);
final List<Object> r1 = finisher.apply(a1);
final List<Object> a2 = supplier.get();
accumulator.accept(a2, t1);
final List<Object> a3 = supplier.get();
accumulator.accept(a3, t2);
final List<Object> r2 = finisher.apply(combiner.apply(a2, a3));
assertThat(r1, Matchers.equalTo(r2));
}
@Test public void identity() {
final List<Object> a1 = supplier.get();
accumulator.accept(a1, t1);
accumulator.accept(a1, t2);
final List<Object> r1 = finisher.apply(a1);
final List<Object> a2 = supplier.get();
accumulator.accept(a2, t1);
accumulator.accept(a2, t2);
final List<Object> r2 = finisher.apply(combiner.apply(a2, supplier.get()));
assertThat(r1, equalTo(r2));
}
@Test public void reversing() throws Exception {
final List<Object> a2 = supplier.get();
accumulator.accept(a2, t1);
accumulator.accept(a2, t2);
final List<Object> a3 = supplier.get();
accumulator.accept(a3, t3);
accumulator.accept(a3, t4);
final List<Object> r2 = finisher.apply(combiner.apply(a2, a3));
assertThat(r2, contains(t4, t3, t2, t1));
}
public static <T> Collector<T, List<T>, List<T>> inReverse() {
return Collector.of(
ArrayList::new,
(l, t) -> l.add(t),
(l, r) -> {l.addAll(r); return l;},
Lists::<T>reverse);
}
}
Comparable<T> 接口（如 Integer、String、Date），您可以使用 Comparator.reverseOrder() 方法来实现。List<Integer> list = Arrays.asList(1, 2, 3, 4);
list.stream()
.sorted(Comparator.reverseOrder())
.forEach(System.out::println);
Stream.of(1,3,2)，结果将是 Stream.of(3,2,1) 而不是 Stream.of(2,3,1)。 - wilmolcyclops-react 的 StreamUtils 具有一个反向的 Stream 方法 (javadoc)。
StreamUtils.reverse(Stream.of("1", "2", "20", "3"))
.forEach(System.out::println);
它的工作原理是通过收集到一个ArrayList，然后利用ListIterator类进行迭代，该类可以向前或向后迭代，以向列表后方迭代。
如果您已经有一个List，那么效率会更高。
StreamUtils.reversedStream(Arrays.asList("1", "2", "20", "3"))
.forEach(System.out::println);
List<Integer> list = Arrays.asList(1,2,3,4);
Seq.seq(list).reverse().forEach(System.out::println)
就是这么简单。它是一个相当轻量级的库，非常值得添加到任何Java 8项目中。
IntStream没有.sorted(Comparator)方法；你必须先通过一个Stream<Integer>并在那里反转后再产生一个IntStream。 - fgeIntStream.range(0, n)，可以使用类似于map(i -> n - i - 1)的方式。无需进行装箱和排序。 - Stuart Marks1, 3, 2，您期望的结果是什么？您想要倒转后的“流”，例如2, 3, 1，还是排序后的“流”，例如3, 2, 1？ - chiccodoro