Java8 Streams中的Lazy sorted()，每次迭代都需要重新排序

Question

我正在寻找一种方法来模拟 Java 8 流的以下行为。 给定一个年份流，对它们进行排序，以便输出前 10 个值，这样 输出一年后，减少，迭代重新开始：

如果我输入 2005、2020、2000、1967 和 2018 年，我预计以下结果（限制为 10）：

2020
2019
2018 2018  
2017 2017
2016 2016 2016
2015 ...

我正在使用的测试是：

public class LazyTest {

    public static void main(String[] args) {
        Stream.of(2005,2020,2000,1967,2018)
              .map(YearWrapper::new)
              .sorted()
              .limit(10)
              .peek(year -> year.decreaseYear())
              .forEach(System.out::println);
    }

    public static class YearWrapper implements Comparable<YearWrapper>{
        private int currentYear;

        public YearWrapper(int year){
            this.currentYear=year;
        }
        public void decreaseYear(){
            currentYear--;
        }
        @Override
        public int compareTo(YearWrapper yearsToCompare) {
            return Integer.compare(yearsToCompare.currentYear, this.currentYear);
        }

        @Override
        public String toString(){
            return String.valueOf(currentYear);
        }
    }
}

但似乎 sorted() 一点也不懒惰。整个排序在开始时进行一次，因此在任何进一步操作之前计算顺序，因此，示例的 5 个值是按顺序传递的，因此 reduce() 对迭代没有实际影响。

有没有办法让 sorted() 变得惰性并在流式传输下一个元素之前再次应用于剩余元素？

任何其他接近的方法将不胜感激！

Answer 1

documentation of Stream.sorted() 说：

这是stateful intermediate operation。

又是described as

有状态操作可能需要在产生结果之前处理整个输入。例如，在查看流的所有元素之前，无法通过对流进行排序产生任何结果。

这记录了排序的非惰性性质，但是，这与您的问题无关。即使排序是惰性的，但它并没有改变流的基本原则，即每个项目最多一次流到终端操作。

您说您希望排序“是懒惰的”，但您实际上期望的是在消费后对每个项目再次进行排序，这意味着对 n 元素流进行排序实际上意味着将 n 个项目排序 n 次，这是其他人都不会想到的，尤其是 peek 并不意味着会产生影响正在进行的操作的副作用。

Answer 2

我是否正确地理解你，你想从列表中取出最大的数字，递减它，把它放回列表中，重复 10 次？

如果是这样，那么这是PriorityQueue 的工作：

PriorityQueue<Integer> queue = Stream.of(2005,2020,2000,1967,2018)
        .collect(toCollection(() -> new PriorityQueue(reverseOrder())));

Stream.generate(() -> {
    Integer year = queue.poll();
    queue.add(year - 1);
    return year;
}).limit(10).forEach(System.out::println);