一般问题:什么是反转流的正确方法?假设我们不知道流由什么类型的元素组成，反转任何流的通用方法是什么?
具体问题:
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)
我错过了什么?
当前回答
如何避免这样做:
不要使用.sorted(Comparator.reverseOrder())或.sorted(Collections.reverseOrder())，因为它只会按降序排序元素。 对于给定的Integer输入使用它: [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重复地打破这个。.boxed范围(0 10000).parallel()()。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]
其他回答
以下是我想出的解决方案:
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...
我就是这么做的。
我不喜欢创建一个新集合并反向迭代它的想法。
IntStream#映射的想法是非常整洁的，但我更喜欢IntStream#迭代方法，因为我认为倒计时到零的想法更好地表达了迭代方法，更容易理解从后面到前面的数组行走。
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 -> array[index]);
}
public static DoubleStream reverseStream(final double[] array) {
return countdownFrom(array.length - 1).mapToDouble(index -> array[index]);
}
public static <T> Stream<T> reverseStream(final T[] array) {
return countdownFrom(array.length - 1).mapToObj(index -> array[index]);
}
public static IntStream countdownFrom(final int top) {
return IntStream.iterate(top, t -> t - 1).limit(max(0, (long) top + 1));
}
下面是一些测试来证明它是有效的:
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 -> x == MAX_VALUE));
}
@Test
public void testCountdownFrom_givesZeroLengthCountForNegativeValues() {
assertArrayEquals(new int[0], countdownFrom(-1).toArray());
assertArrayEquals(new int[0], countdownFrom(-4).toArray());
}
如何避免这样做:
不要使用.sorted(Comparator.reverseOrder())或.sorted(Collections.reverseOrder())，因为它只会按降序排序元素。 对于给定的Integer输入使用它: [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重复地打破这个。.boxed范围(0 10000).parallel()()。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]
List newStream = list.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());
newStream.forEach(System.out::println);
在所有这些问题中，我没有看到我首先要回答的答案。
这并不是对这个问题的直接回答，但却是一个潜在的解决方案。
只要一开始就逆向构建列表。如果可以的话，使用LinkedList而不是ArrayList，当你添加项目时使用“Push”而不是add。列表将以相反的顺序构建，然后将正确地流，而不需要任何操作。
这并不适用于您正在处理原始数组或列表的情况，这些原始数组或列表已经以各种方式使用，但在令人惊讶的大量情况下工作得很好。
