Get ultimi n elementi dal flusso

Question

mi chiedo c'è un'alternativa al

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

con stream utilizzo?

Answer 1

È possibile scrivere un collettore personalizzato come questo:

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

e usarlo in questo modo:

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

Answer 2

Uso Stream.skip()

restituisce un flusso costituito dai restanti elementi di questo flusso dopo scartando i primi n elementi del flusso. Se questo flusso contiene meno di n elementi, verrà restituito uno stream vuoto.

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

Answer 3

Nel caso in cui il torrente ha una dimensione sconosciuta, probabilmente non c'è modo per aggirare consumando l'intero flusso e il buffering ultimi n elementi incontrati finora. Puoi farlo usando un qualche tipo di deque, o un buffer ad anello specializzato che mantiene automaticamente la sua dimensione massima (vedi this related question per alcune implementazioni).

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

Tutte queste operazioni (size, pop, add) dovrebbe avere complessità O (1), quindi complessità generale per un flusso con (sconosciuta) lunghezza n sarebbe O (n).