जावा स्ट्रीम को कैसे कार्यान्वित करें?

Question

मैं Stream<T> को कार्यान्वित करना चाहता हूं।

मैं सिर्फ implements Stream<T> का उपयोग नहीं करना चाहता, क्योंकि मुझे विधियों का एक टन लागू करना होगा।

क्या इससे बचा जा सकता है?

अधिक ठोस हो, कैसे मैं उदाहरण के लिए t1, t2 और t3 स्ट्रीम कर सकते हैं:

class Foo<T> { 
    T t1, t2, t3; 

    Foo(T t1, T t2, T t3) { 
     this.t1 = t1; 
     this.t2 = t2; 
     this.t3 = t3; 
    } 
} 

Answer 1

JDK के Stream के मानक कार्यान्वयन, आंतरिक वर्ग java.util.stream.ReferencePipeline है आप इसे सीधे का दृष्टांत नहीं कर सकते।

इसके बजाय आप java.util.stream.Stream.builder(), java.util.stream.StreamSupport.stream(Spliterator<T>, boolean) और विभिन्न ^{1, 2} अन्य स्थिर कारखाने तरीकों का उपयोग डिफ़ॉल्ट कार्यान्वयन का एक उदाहरण बनाने के लिए कर सकते हैं।

एक स्प्लिटरेटर का उपयोग करना शायद सबसे शक्तिशाली दृष्टिकोण है क्योंकि यह आपको ऑब्जेक्ट्स को आलसी प्रदान करने की अनुमति देता है जबकि कुशल स्रोत समानांतर सक्षम करता है यदि आपका स्रोत एकाधिक हिस्सों में विभाजित किया जा सकता है।

साथ ही आप भी धाराओं वापस spliterators में बदल सकते हैं, उन्हें एक कस्टम spliterator में लपेट और फिर उन्हें एक धारा में वापस परिवर्तित करता है, तो आप अपने खुद के स्टेटफुल मध्यवर्ती संचालन लागू करने की आवश्यकता - जैसे मानक एपीआई में कमियों के कारण - चूंकि अधिकांश उपलब्ध इंटरमीडिएट are not allowed to be stateful से अधिक हैं। उदाहरण के लिए
this SO answer देखें।

सिद्धांत रूप में आप स्ट्रीम इंटरफ़ेस का अपना कार्यान्वयन लिख सकते हैं, लेकिन यह काफी कठिन होगा।

Answer 2

आपको आमतौर पर अपनी स्ट्रीम कक्षा लिखने की आवश्यकता नहीं है। इसके बजाय आप मौजूदा तरीकों से स्ट्रीम बना सकते हैं। उदाहरण के लिए, यहाँ, मान 1 की एक धारा बनाने का तरीका 100 है:

AtomicInteger n = new AtomicInteger(0); 
    Stream<Integer> stream = Stream.generate(() -> n.incrementAndGet()).limit(100); 

इसलिए यहाँ में हम पूर्णांकों की एक अनंत धारा का निर्माण किया: 1, 2, 3, .... फिर हम limit(100) पर इस्तेमाल किया 100 तत्वों की धारा वापस पाने के लिए अनंत स्ट्रीम।

स्पष्टता के लिए, यदि आप पूर्णांक की धारा (निश्चित अंतराल पर) चाहते हैं तो आपको IntStream.range() का उपयोग करना चाहिए। यह दिखाने के लिए सिर्फ एक उदाहरण है कि Stream.generate() का उपयोग करके धाराओं को कैसे परिभाषित किया जा सकता है जो आपको अधिक लचीलापन देता है क्योंकि यह आपको स्टीम के तत्वों को निर्धारित करने के लिए मनमाने ढंग से तर्क का उपयोग करने की अनुमति देता है।

Answer 3

अन्य ने उत्तर दिया है कि सामान्य उद्देश्य Stream कार्यान्वयन कैसे प्रदान किया जाए। अपने विशिष्ट आवश्यकता के बारे में, सिर्फ इस कार्य करें:

class Foo<T> { 

    T t1, t2, t3; 

    Foo(T t1, T t2, T t3) { 
     this.t1 = t1; 
     this.t2 = t2; 
     this.t3 = t3; 
    } 

    Stream<T> stream() { 
     return Stream.of(t1, t2, t3); 
    } 
} 

Answer 4

आप क्योंकि आप कस्टम close() तर्क चाहते स्वयं की स्ट्रीम बनाने की चाह रहे हैं, सरल समाधान एक इटरेटर से एक स्ट्रीम बनाने के लिए है, और onClose(Runnable) फोन ।इतने पर यहाँ

MappingIterator<?> values = objectMapper.reader(type).readValues(reader); 
return StreamSupport 
     .stream(Spliterators.spliteratorUnknownSize(values, Spliterator.ORDERED), false) 
     .onClose(() -> { 
      try { 
       reader.close(); 
      } catch (IOException e) { 
       throw new RuntimeException(e); 
      } 
     }); 

Answer 5

पूर्णता के लिए, के रूप में मैं इस सीधे जवाब के बीच में नहीं मिला: उदाहरण के लिए, जैक्सन के माध्यम से एक रीडर से स्ट्रीम करने के लिए आप एक धारा में एक मौजूदा इटरेटर बदलना चाहते हैं (जैसे, क्योंकि आप सफलतापूर्वक इस तत्व उत्पन्न करना चाहते हैं), इस का उपयोग करें:

StreamSupport.stream(
    Spliterators.spliterator(myIterator, /* initial size*/ 0L, Spliterator.NONNULL), 
    /* not parallel */ false); 

मैं इस कठिन थोड़ा, खोजने के लिए के रूप में आप StreamSupport, Spliterators और Spliterator