我应该如何检查 Stream<T> 是否已排序？

Question

使用Iterable<T>，很容易：

T last = null;
for (T t : iterable) {
    if (last != null && last.compareTo(t) > 0) {
        return false;
    }
    last = t;
}
return true;

但我想不出一种干净的方法来为 Stream<T> 做同样的事情，避免在不必要时消耗所有元素。

Answer 1

您可以获取 Stream 的底层拆分器并检查它是否具有 SORTED 特征。由于它是终端操作，因此您不能在之后使用 Stream（但您可以从此拆分器创建另一个，另见 Convert Iterable to Stream using Java 8 JDK）。

例如：

Stream<Integer> st = Stream.of(1, 2, 3);
//false
boolean isSorted = st.spliterator().hasCharacteristics(Spliterator.SORTED);

Stream<Integer> st = Stream.of(1, 2, 3).sorted();
//true
boolean isSorted = st.spliterator().hasCharacteristics(Spliterator.SORTED);

我的示例显示SORTED 特征仅在您从报告SORTED 特征的源获取流或您在管道上的某个点调用sorted() 时才会出现。

有人可能会争辩说Stream.iterate(0, x -> x + 1); 创建了一个SORTED 流，但不知道迭代应用的函数的语义。这同样适用于Stream.of(...)。

如果管道是无限的，那么它是唯一知道的方法。如果不是，并且拆分器没有报告此特征，则您需要遍历元素并查看它是否不满足您正在寻找的排序特征。

这是您已经使用迭代器方法完成的操作，但是您需要消耗 Stream 的一些元素（在最坏的情况下，所有元素）。您可以使用一些额外的代码使任务可并行化，然后由您决定是否值得...

Answer 2

您可以将allMatch 与多行 lambda 一起使用，并根据前一个值检查当前值。不过，您必须将最后一个值包装到一个数组中，以便 lambda 可以修改它。

// infinite stream with one pair of unsorted numbers
IntStream s = IntStream.iterate(0, x -> x != 1000 ? x + 2 : x - 1);
// terminates as soon as the first unsorted pair is found
int[] last = {Integer.MIN_VALUE};
boolean sorted = s.allMatch(x -> {
    boolean b = x >= last[0]; last[0] = x; return b; 
});

或者，只需从流中获取 iterator 并使用简单的循环。

Answer 3

您可以劫持减少操作以保存最后一个值并将其与当前值进行比较，如果未排序则抛出异常：

.stream().reduce((last, curr) -> {
   if (((Comparable)curr).compareTo(last) < 0) {
       throw new Exception();
    }

    return curr;
});

编辑：我分叉了另一个答案的示例并将其替换为我的代码，以显示它只执行必要数量的检查。

http://ideone.com/ZMGnVW

Answer 4

一个简单的解决方案使用流的迭代器：

public static <T extends Comparable<T>> boolean isSorted(Stream<T> stream) {
    Iterator<T> i = stream.iterator();
    if(!i.hasNext()) return true;
    T current = i.next();
    while(i.hasNext()) {
        T next = i.next();
        if(current == null || current.compareTo(next) > 0) return false;
        current = next;
    }
    return true;
}

编辑：也可以使用拆分器来并行化任务，但收益值得怀疑，而且复杂性的增加可能不值得。

Answer 5

有几种方法可以迭代流的连续对。例如，您可以查看this question。当然我最喜欢的方法是使用the library我写道：

boolean unsorted = StreamEx.of(sourceStream)
                           .pairMap((a, b) -> a.compareTo(b) > 0)
                           .has(true);

这是短路操作：一旦发现错误就会结束。它也适用于并行流。

Answer 6

这是一个顺序的、状态保持的解决方案：

IntStream stream = IntStream.of(3, 3, 5, 6, 6, 9, 10);
final AtomicInteger max = new AtomicInteger(Integer.MIN_VALUE);
boolean sorted = stream.allMatch(n -> n >= max.getAndSet(n));

并行化需要引入范围。状态，max 可能会以其他方式处理，但上面似乎最简单。

Answer 7

我不知道它有多好，但我有一个想法：

1. 从您的 Stream 、 Integer 或 Strings 或任何东西中创建一个列表。
2. 我为List<String> listOfStream写了这篇文章：

        long countSorted = IntStream.range(1, listOfStream.size())
                .map(
                        index -> {
                            if (listOfStream.get(index).compareTo(listOfStream.get(index-1)) > 0) {
                                return 0;
                            }
                            return index;
                        })
                .sum();