Nhận n phần tử cuối cùng từ dòng

Question

tôi tự hỏi là có một thay thế cho

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

với stream sử dụng?

Answer 1

Bạn có thể viết một nhà sưu tập tùy chỉnh như thế này:

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<T>::new); 
} 

Và sử dụng nó như thế này:

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

Answer 2

Sử dụng Stream.skip()

Trả về một dòng gồm các yếu tố còn lại của dòng này sau khi loại bỏ các yếu tố n đầu tiên của dòng. Nếu luồng này chứa ít hơn n phần tử thì luồng trống sẽ được trả lại.

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

Answer 3

Trong trường hợp dòng có kích thước không rõ, có lẽ không có cách nào xung quanh tiêu thụ toàn bộ dòng và đệm n yếu tố cuối cùng gặp cho đến nay. Bạn có thể làm điều này bằng cách sử dụng một số loại deque, hoặc một vòng đệm chuyên dụng tự động duy trì kích thước tối đa của nó (xem this related question cho một số triển khai).

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); 
} 

Tất cả những hoạt động (size, pop, add) nên có độ phức tạp của O (1), vì vậy mức độ phức tạp tổng thể cho một dòng với chiều dài (không rõ) n sẽ O (n).