जावा में एक इटरेटर क्लोन करें?

Question

एक खेल मैं खिलाड़ियों की एक सूची है में, इस तरह मान लीजिए:

LinkedList<String> players = new LinkedList<String>(); 

मैं प्रत्येक खिलाड़ी अन्य खिलाड़ियों में से प्रत्येक के साथ बातचीत बताना चाहते हैं, तो मैं दो नेस्टेड छोरों लिखें:

Iterator<String> i1 = players.iterator(); 
while (i1.hasNext()) { 
    String p1 = i1.next(); 
    Iterator<String> i2 = players.iterator(); 
    // But I want to do this: Iterator<String> i2 = i1.clone(); 
    while (i2.hasNext()) { 
     String p2 = i2.next(); 
     System.out.println("Interact: " + p1 + ", " + p2); 
    } 
} 

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

तो, मुझे इसके बजाय क्या करना चाहिए?

Answer 1

निम्नलिखित यह करना होगा:

ListIterator<String> i1 = players.listIterator(0); 
while (i1.hasNext()) { 
    String p1 = i1.next(); 
    ListIterator<String> i2 = players.listIterator(i1.nextIndex()); 
    while (i2.hasNext()) { 
     String p2 = i2.next(); 
     System.out.println("Interact: " + p1 + ", " + p2); 
    } 
} 

यह ListIterator की दी गई स्थिति से शुरू करने के लिए और भी अपने मौजूदा स्थिति पता करने की क्षमता पर निर्भर करता है।

Answer 2

aix answer के अलावा, मैं यह इंगित करना चाहता हूं कि हालांकि आप एक विशिष्ट इंडेक्स से शुरू होने वाला एक इटरेटर बनाते हैं, यह एक रैखिक ऑपरेशन होने के लिए बाध्य है। यदि ऐसा नहीं था, तो आप

elementN = createIterator(linkedList, N).next(); 

जो विरोधाभासी होगा का उपयोग कर लगातार समय में सूची में मनमाने ढंग से उपयोग कर सकते करने में सक्षम हो जाएगा।

अपनी स्थिति में मैं इसलिए मानते हैं कि सबसे कुशल समाधान वास्तव में हालांकि ऐसा करने के लिए

List<String> tmp = new ArrayList<String>(players); 
for (int p1 = 0; p1 < tmp.size(); p1++) 
    for (int p2 = p1+1; p2 < tmp.size(); p2++) 
     System.out.println("Interact: " + tmp.get(p1) + ", " + tmp.get(p2)); 

नोट हो सकता है, कि यह है अभी भी aix द्वारा समाधान के रूप में एक ही जटिलता; ओ (एन) लेकिन शायद एक छोटे स्थिर कारक के साथ।

Answer 3

listIterator(int) (एनपीई का उत्तर) से जुड़े रैखिक लागत से बचने वाले समाधान के लिए, मेरे answer to a similar question देखें। संक्षेप में, जब तक आप सूची का दौरा करने के आदेश की परवाह नहीं करते हैं, तब तक आप अंतिम तत्व से बाहरी पाश शुरू कर सकते हैं और फिर से दोहरा सकते हैं, और पहले तत्व से आंतरिक पाश शुरू कर सकते हैं और दो पुनरावृत्तियों तक आगे बढ़ सकते हैं मिलते हैं। List.listIterator (list.size()) पर कॉल तेज़ है क्योंकि सूची एक लिंक्डलिस्ट है, यानी एक दोगुनी-लिंक्ड सूची है, और अंतिम तत्व तक पहुंचने के लिए सूची के माध्यम से पुनरावृत्ति की आवश्यकता नहीं है। नीचे उदाहरण देखें:

public static int iterRevIterator(List<Integer> list) { 
    int sum = 0; 
    for(ListIterator<Integer> outer = list.listIterator(list.size()); outer.hasPrevious();) { 
     Integer oVal = outer.previous(); 
     for(ListIterator<Integer> inner = list.listIterator(); inner.nextIndex() <= outer.previousIndex();) { 
      sum += oVal * inner.next(); 
     } 
    } 
    return sum; 
}