一般问题:什么是反转流的正确方法?假设我们不知道流由什么类型的元素组成，反转任何流的通用方法是什么?
具体问题:
IntStream提供了在特定范围内生成整数的range方法。range(-range, 0)，现在我想反转它，从0到负切换范围将不起作用，我也不能使用Integer::比较
List<Integer> list = Arrays.asList(1,2,3,4);
list.stream().sorted(Integer::compare).forEach(System.out::println);
使用IntStream，我将得到这个编译器错误
错误:(191,0)ajc: IntStream类型中的sorted()方法不适用于参数(Integer::compare)
我错过了什么?
当前回答
ArrayDeque在堆栈中比stack或LinkedList更快。"push()"将元素插入到Deque的前面
protected <T> Stream<T> reverse(Stream<T> stream) {
ArrayDeque<T> stack = new ArrayDeque<>();
stream.forEach(stack::push);
return stack.stream();
}
其他回答
最简单的方法(simple collect -支持并行流):
public static <T> Stream<T> reverse(Stream<T> stream) {
return stream
.collect(Collector.of(
() -> new ArrayDeque<T>(),
ArrayDeque::addFirst,
(q1, q2) -> { q2.addAll(q1); return q2; })
)
.stream();
}
高级方式(以持续的方式支持并行流):
public static <T> Stream<T> reverse(Stream<T> stream) {
Objects.requireNonNull(stream, "stream");
class ReverseSpliterator implements Spliterator<T> {
private Spliterator<T> spliterator;
private final Deque<T> deque = new ArrayDeque<>();
private ReverseSpliterator(Spliterator<T> spliterator) {
this.spliterator = spliterator;
}
@Override
@SuppressWarnings({"StatementWithEmptyBody"})
public boolean tryAdvance(Consumer<? super T> action) {
while(spliterator.tryAdvance(deque::addFirst));
if(!deque.isEmpty()) {
action.accept(deque.remove());
return true;
}
return false;
}
@Override
public Spliterator<T> trySplit() {
// After traveling started the spliterator don't contain elements!
Spliterator<T> prev = spliterator.trySplit();
if(prev == null) {
return null;
}
Spliterator<T> 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<? super T> getComparator() {
Comparator<? super T> comparator = spliterator.getComparator();
return (comparator != null) ? comparator.reversed() : null;
}
@Override
public void forEachRemaining(Consumer<? super T> 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());
}
注意，您可以快速扩展到其他类型的流(IntStream，…)。
测试:
// Use parallel if you wish only
revert(Stream.of("One", "Two", "Three", "Four", "Five", "Six").parallel())
.forEachOrdered(System.out::println);
结果:
Six
Five
Four
Three
Two
One
其他注意事项:最简单的方法是，当它与其他流操作一起使用时就不那么有用了(收集连接破坏了并行性)。前进的方式就没有这个问题，它也保持了流的初始特征，比如排序，所以，它是在反向操作之后用于其他流操作的方式。
以下是我想出的解决方案:
private static final Comparator<Integer> BY_ASCENDING_ORDER = Integer::compare;
private static final Comparator<Integer> BY_DESCENDING_ORDER = BY_ASCENDING_ORDER.reversed();
然后使用这些比较器:
IntStream.range(-range, 0).boxed().sorted(BY_DESCENDING_ORDER).forEach(// etc...
ArrayDeque在堆栈中比stack或LinkedList更快。"push()"将元素插入到Deque的前面
protected <T> Stream<T> reverse(Stream<T> stream) {
ArrayDeque<T> stack = new ArrayDeque<>();
stream.forEach(stack::push);
return stack.stream();
}
我们可以编写一个收集器，以相反的顺序收集元素:
public static <T> Collector<T, ?, Stream<T>> reversed() {
return Collectors.collectingAndThen(Collectors.toList(), list -> {
Collections.reverse(list);
return list.stream();
});
}
像这样使用它:
Stream.of(1, 2, 3, 4, 5).collect(reversed()).forEach(System.out::println);
原来的答案(包含一个错误-它不能正确工作的并行流):
一个通用的流反向方法可以是这样的:
public static <T> Stream<T> reverse(Stream<T> stream) {
LinkedList<T> stack = new LinkedList<>();
stream.forEach(stack::push);
return stack.stream();
}
回答与IntStream反转的具体问题，以下工作对我来说:
IntStream.range(0, 10)
.map(x -> x * -1)
.sorted()
.map(Math::abs)
.forEach(System.out::println);
