धारा

Question

मैं सोच रहा हूं, उनसे पिछले n तत्वों जाओ वहाँ stream उपयोग के साथ

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

लिए एक विकल्प है?

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

और इस तरह इसका इस्तेमाल:

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

Answer 2

उपयोग Stream.skip()

धारा के पहले n तत्वों की निकालने के बाद इस धारा के शेष तत्वों से मिलकर एक धारा देता है। यदि इस स्ट्रीम में एन तत्वों से कम है तो एक खाली स्ट्रीम वापस कर दी जाएगी।

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

Answer 3

मामले में धारा अज्ञात आकार की है, वहाँ शायद कोई रास्ता नहीं चारों ओर पूरे धारा लगता है और पिछले n तत्वों अब तक का सामना करना पड़ा बफरिंग है। आप इसे किसी प्रकार का डेक, या एक विशेष रिंग-बफर स्वचालित रूप से अपने अधिकतम आकार को बनाए रखने के द्वारा कर सकते हैं (कुछ कार्यान्वयन के लिए 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) की जटिलता होना चाहिए हे (1), इसलिए साथ (अज्ञात) लंबाई एक धारा के लिए समग्र जटिलता nO (n होगा)।