Question

我想知道是否有替代

List<X> lastN = all.subList(Math.max(0, all.size() - n), all.size());

使用stream？

Answer 1

自定义收集器可以这样写：

public static <T> Collector<T, ?, List<T>> lastN(int n) {
    return Collector.<T, Deque<T>, List<T>>of(ArrayDeque::new, (acc, t) -> {
        if(acc.size() == n)
            acc.pollFirst();
        acc.add(t);
    }, (acc1, acc2) -> {
        while(acc2.size() < n && !acc1.isEmpty()) {
            acc2.addFirst(acc1.pollLast());
        }
        return acc2;
    }, ArrayList::new);
}

并像这样使用它：

List<String> lastTen = input.stream().collect(lastN(10));

Answer 2

使用Stream.skip()

在丢弃流的前n个元素后，返回由此流的其余元素组成的流。如果此流包含少于n个元素，则将返回空流。

all.stream().skip(Math.max(0, all.size() - n)).forEach(doSomething);

Answer 3

如果流的大小未知，那么可能无法使用整个流并缓冲到目前为止遇到的最后n个元素。您可以使用某种deque或自动保持其最大大小的专用环形缓冲区来执行此操作（对于某些实现，请参阅this related question）。

public static <T> List<T> lastN(Stream<T> stream, int n) {
    Deque<T> result = new ArrayDeque<>(n);
    stream.forEachOrdered(x -> {
        if (result.size() == n) {
            result.pop();
        }
        result.add(x);
    });
    return new ArrayList<>(result);
}

所有这些操作（size，pop，add）都应该具有 O（1）的复杂性，因此具有流的整体复杂性（未知）长度 n 将 O（n）。

Answer 4

有时候我需要一个“单一的”（在这种情况下是三个衬垫），因为创建收集器太麻烦了。

如果流很小，则可以再次reverse，limit和reverse，而不会牺牲很多性能。这将导致最后n个元素。

如果需要过滤，这很有用，因为在这种情况下，无法指定大小。

Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
  .filter(i -> i % 2 == 0)
  .sorted(Comparator.reverseOrder())
  .limit(2)
  .sorted(Comparator.reverseOrder())
  .forEach(System.out::println); // prints 8 6

从流中获取最后n个元素

4 个答案: