दो जावा -8-स्ट्रीम एक साथ

Question

मैं दो जावा -8-स्ट्रीम एक साथ फिर से शुरू करना चाहता हूं, ताकि मेरे प्रत्येक पुनरावृत्ति चरण में दो तर्क हो। ऐसा कुछ, जहां somefunctionStream<Pair<A,B>> जैसे कुछ उत्पन्न करता है।

Stream<A> as; 
Stream<B> bs; 
somefunction (as, bs) 
    .forEach ((a, b) -> foo (a, b)); 
// or something like 
somefunction (as, bs) 
    .forEach ((Pair<A, B> abs) -> foo (abs.left(), abs.right())); 

मैं जानना चाहता हूँ, अगर जावा ऐसा ही कुछ प्रदान करता है, यद्यपि वहाँ है जावा में कोई Pair :-(यदि ऐसा कोई एपीआई-समारोह है, वहाँ simultaniously दो धाराओं पुनरावृत्ति का एक और तरीका है?

Answer 1

static <A, B> Stream<Pair<A, B>> zip(Stream<A> as, Stream<B> bs) 
{ 
    Iterator<A> i=as.iterator(); 
    return bs.filter(x->i.hasNext()).map(b->new Pair<>(i.next(), b)); 
} 

यह समानांतर निष्पादन की पेशकश नहीं करता है लेकिन मूल zip कार्यान्वयन भी नहीं किया गया है।

और F. Böller has pointed out के रूप में यह काम नहीं करता है अगर bs अनंत है और as नहीं है। एक समाधान है जो अनंत और परिमित धाराओं के सभी संभव संयोजनों के लिए काम करता है, एक मध्यवर्ती Iterator जो hasNext विधि के भीतर दोनों स्रोतों की जाँच करता है unavoidable¹ लगता है के लिए:

static <A, B> Stream<Pair<A,B>> zip(Stream<A> as, Stream<B> bs) { 
    Iterator<A> i1 = as.iterator(); 
    Iterator<B> i2 = bs.iterator(); 
    Iterable<Pair<A,B>> i=()->new Iterator<Pair<A,B>>() { 
     public boolean hasNext() { 
      return i1.hasNext() && i2.hasNext(); 
     } 
     public Pair<A,B> next() { 
      return new Pair<A,B>(i1.next(), i2.next()); 
     } 
    }; 
    return StreamSupport.stream(i.spliterator(), false); 
} 

आप समानांतर सक्षम ज़िप करने चाहते हैं तो आप के स्रोत पर विचार करना चाहिए Stream। जैसे आप की तरह

ArrayList<Foo> l1=new ArrayList<>(); 
ArrayList<Bar> l2=new ArrayList<>(); 
IntStream.range(0, Math.min(l1.size(), l2.size())) 
     .mapToObj(i->new Pair(l1.get(i), l2.get(i))) 
     . … 

---

¹ दो ArrayList रों (या किसी भी RandomAccessList) ज़िप कर सकते हैं

Answer 2

AFAIK आपकी आवश्यकता की तरह कुछ भी नहीं है लेकिन आप क्या कर सकते हैं दो धागे बनाते हैं और धाराओं को इन थ्रेडों में पास करते हैं। प्रत्येक धागा धाराओं को फिर से सक्रिय करेगा और उस पर कुछ तर्क लागू करेगा। थ्रेड सृजन जावा 8 के साथ आसान तरीका है

new Thread(
    () -> System.out.println("hello world") 
).start();