जावा में यील्ड रिटर्न

Question

मैंने जेनिक्स का उपयोग करके जावा में एक लिंक्ड सूची बनाई है, और अब मैं सूची में सभी तत्वों को फिर से चलाने में सक्षम होना चाहता हूं। सी # में सूची में निहित तत्वों की सूची के दौरान लिंक किए गए सूची के अंदर yield return का उपयोग किया जाएगा।

मैं उपरोक्त का जावा संस्करण बनाने के बारे में कैसे जाउंगा जहां मैं लिंक की गई सूची में मौजूद सभी वस्तुओं पर पुन: प्रयास कर सकता हूं?

मैं आला

LinkedList<something> authors = new LinkedList<something>(); 
for (Iterator<something> i = authors.Values ; i.HasNext()) 
     doSomethingWith(i.Value); 

कोड लिखने के लिए सक्षम होने के लिए देख रहा हूँ और सोच रहा था कि मूल्य 'संपत्ति'/विधि जैसी

LinkedListObject<something> current = first; 
While (current != null){ 
yield return current.getValue(); 
current = current.getNext() 
} 

संपादित कोड शामिल होंगे: ध्यान दें कि मैं मुझे किसी भी तृतीय पक्ष एपीआई का उपयोग करने में दिलचस्पी नहीं है। अंतर्निहित जावा कार्यक्षमता केवल।

Answer 1

क्या मुझे यहां कुछ याद आ रही है? पहले से ही java.util.LinkedList है, यह पूरी तरह से जेनेरिक-सक्षम है, और इसमें एक विधि है जो एक इटरेटर लौटाती है।

यदि आप वास्तव में पहिया का पुन: आविष्कार करना चाहते हैं, तो मैं सुझाव दूंगा कि आप लिंक्ड लिस्ट इटरेटर कक्षा बनाने की तलाश में हैं, शायद सूचीकरणकर्ता को लागू करना।यह लिंक की गई सूची में अपनी वर्तमान स्थिति को याद रखेगा और इसे प्रत्येक क्रमिक कॉल पर अग्रिम करेगा।

Answer 2

इस

• com.infomancers.collections.yield

जांच एक नमूना कार्यान्वयन के लिए इस लेख के रूप में अच्छी तरह से प्रयास करें:

• Implementation details for Java Yielder

Answer 3

मैं समझने के लिए उपज करता है की कोशिश की है परंतु सी # अनुभव के बिना मुझे यकीन है कि मेरे पास है, लेकिन मैं वैसे भी कोशिश करेंगे, तो नहीं कर रहा हूँ ...

मैं इसे एक विधि से मूल्यों को लौटने की बात आती है सुझाव है कि निम्नलिखित ...

Something answer = null; 
for (Something author: authors){ 

    if (author.equals("Tom Jones"){ 
    answer = author; 
    break; 
    } 
} 

मैं निम्नलिखित करेंगे ...

public LinkedList<something> getAuthors(LinkedList<something> list){ 
     LinkedList<something> ret = new LinkedList<something>(); 
     for (something s:list){ 
     if (s.equals("abc")) 
      ret.add(s); 
     } 
     return ret; 
    } 

क्या मैंने साजिश खो दी है?

Answer 4

यदि आप yield return की पूर्ण कार्यक्षमता चाहते हैं, तो आपको शायद इसे दो थ्रेड में सेट करना होगा - एक पहली विधि के लिए, और एक दूसरे के लिए। फिर पहला धागा wait होना चाहिए जब तक कि दूसरा धागा अपना मूल्य कहीं भी सुलभ न हो और notify यह तैयार हो। फिर पहला धागा उस मान को संसाधित करेगा, wait अगले मूल्य के लिए,

Answer 5

मुझे समझ में नहीं आता कि लोग धागे के बारे में क्यों बात कर रहे हैं ... क्या मुझे कुछ उपज रिटर्न के बारे में पता नहीं है?

मेरी समझ के लिए उपज वापसी केवल विधि ढेर को बचाती है और इसे बाद में पुनर्स्थापित करती है। उपज रिटर्न को लागू करने के लिए आपको बस राज्य को मैन्युअल रूप से सहेजना होगा। विवरण के लिए जावा इटरेटर कक्षाएं देखें, हालांकि एक लिंक्ड सूची के लिए आप वर्तमान आइटम को सहेजने से दूर हो सकते हैं। एक सरणी के लिए आपको केवल इंडेक्स की आवश्यकता होगी।

Answer 6

पाठकों को छोटे विवरणों को समझने में मदद करने के लिए।

यदि आप सभी परिणामी तत्वों वाली एक नई सूची बनाते हैं और सूची वापस करते हैं, तो यह कोड के लिए पर्याप्त सरल कार्यान्वयन है। आपको आवश्यकतानुसार रोचक डेटा संरचना के रूप में हो सकता है, और सही प्रविष्टियों के लिए स्कैन करते समय, बस सभी मैचों की एक सूची वापस कर दें, और आपका ग्राहक सूची में फिर से चालू होगा।

यदि आप एक राज्य को सहेजना चाहते हैं, तो यह अधिक जटिल हो सकता है। आपको हर बार जहां आपका फ़ंक्शन कहा जाता है, वहां जाना होगा। पुन: प्रवेश करने वाले मुद्दों का उल्लेख नहीं करना, आदि

धागे के साथ समाधान एक नई सूची नहीं बनाता है। और यह पहला समाधान जितना सरल है। एकमात्र मुद्दा यह है कि आप एक थ्रेड सिंक्रनाइज़ेशन शामिल करते हैं जो कोड के लिए थोड़ा कठिन है, और इसकी प्रदर्शन दंड है।

तो, हाँ, उपज वापसी महान है और जावा से गायब है। फिर भी कामकाज हैं।

Answer 7

आप इटेबल के अज्ञात कार्यान्वयन को वापस कर सकते हैं। प्रभाव बहुत सुंदर हैं, बस यह कि बहुत अधिक verbose है।

public Iterable<String> getStuff() { 
    return new Iterable<String>() { 

     @Override 
     public Iterator<String> iterator() { 
      return new Iterator<String>() { 

       @Override 
       public boolean hasNext() { 
        // TODO code to check next 
       } 

       @Override 
       public String next() { 
        // TODO code to go to next 
       } 

       @Override 
       public void remove() { 
        // TODO code to remove item or throw exception 
       } 

      }; 
     } 
    }; 
} 

Answer 8

"उपज वापसी" एक बहुत ही परिष्कृत संकलक चाल है। यह मूल रूप से आपको अपने इटेटरेटर को बनाने के तरीके को "समझने" के किसी भी कष्टप्रद विवरण के बिना आईन्यूमेरेबल को घोषणात्मक रूप से लागू करने देता है। दुर्भाग्यपूर्ण बात यह है कि यह अन्य भाषाओं में अनुवाद नहीं करता है क्योंकि बहुत कम कंपेलरों की क्षमता ऐसी होती है। कुछ तरीकों से "उपज वापसी" क्रांतिकारी के रूप में हानिकारक है।

मूल रूप से सी # में, कंपाइलर IENumerable और IENumerator (टी) के दो कार्यान्वयन उत्पन्न करेगा। यह मूल रूप से आपके "विधि" के स्थानीय चर को साकार करके कार्यान्वित कार्यान्वयन कक्षाओं के उदाहरण के साथ-साथ "उपज रिटर्न" आर्टिफैक्ट युक्त फ़्रेम की जांच के रूप में भी महसूस करता है। एक बार जब आप इसे जानते हैं, तो एक अच्छी तरह से गोल करने वाले डेवलपर के लिए एक ही चीज़ को स्पष्ट रूप से पूरा करना संभव होना चाहिए ... हालांकि संक्षेप में नहीं। प्रदर्शित करने के लिए, मैं कंक्रीट करूँगा!

public static <T> Iterable<T> concat(Iterable<T> x, Iterable<T> y) 
{ 
    for(T e: x) 
    { 
     yield return e; 
    } 

    for(T e: y) 
    { 
     yield return e; 
    } 
} 

// becomes .... 

public static <E> Iterator<E> concat_(Iterable<E> x, Iterator<E> y) 
{ 
    T e1, e2; 
    Iterator<E> i1, i2; 

    Iterator<E> s; 
    Iterator<E> s4 = new Iterator<E>() 
    { 
     public bool hasNext() 
     { 
      return false; 
     } 

     public E next() 
     { 
      throw ... ; 
     } 

     public void remove() 
     { 
      throw ... ; 
     } 
    } 

    Iterator<E> s3 = new Iterator<E>() 
    { 
     Iterator<E> act() 
     { 
      if(i2.hasNext()) 
      { 
       return i2; 
      } 

      i2 = y.iterator(); 
      return (s = s4); 
     } 

     public bool hasNext() 
     { 
      return act().hasNext(); 
     } 

     public E next() 
     { 
      return act().next(); 
     } 

     public void remove() 
     { 
      return i2.remove(); 
     } 
    } 

    Iterator<E> s2 = new Iterator<E>() 
    { 
     Iterator<E> act() 
     { 
      if(i1.hasNext()) 
      { 
       return i1; 
      } 

      i2 = y.iterator(); 
      return (s = s3); 
     } 

     public bool hasNext() 
     { 
      return act().hasNext(); 
     } 

     public E next() 
     { 
      return act().next(); 
     } 

     public void remove() 
     { 
      return i1.remove(); 
     } 
    }; 

    Iterator<E> s1 = new Iterator<E>() 
    { 
     Iterator<E> act() 
     { 
      i1 = x.iterator(); 
      return s = s2; 
     } 

     public bool hasNext() 
     { 
      return act().hasNext(); 
     } 

     public E next() 
     { 
      return act().next(); 
     } 

     public void remove() 
     { 
      return act().remove(); 
     } 
    }; 

    s = s1; 
    return new Iterator<T>() 
    { 
     public bool hasNext() 
     { 
      return s.hasNext(); 
     } 

     public E next() 
     { 
      return s.next(); 
     } 

     public void remove() 
     { 
      return s.remove(); 
     } 
    }; 
} 

public static <T> Iterable<T> concat(Iterable<T> x, Iterable<T> y) 
{ 
    return new Iterable<T>() 
    { 
     public Iterator<T> iterator() 
     { 
      return concat_(x, y) 
     } 
    }; 
} 

// tada! 

आप सभी मेरी 3:00 छद्म जावा क्षमा करेंगे, तो ...

Answer 9

धागे या बाइट कोड हेरफेर

http://www.heinerkuecker.de/YieldReturnForNested.html