सूचियों के माध्यम से लूपिंग, बेहतर विधि

Question

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

निम्नलिखित उदाहरण में, मैं सूचियों के माध्यम से लूपिंग कर रहा हूं और काउंटर का उपयोग कर रहा हूं, कई बार मुझे आउटपुट में इंडेक्स काउंटर शामिल करना पड़ा।

मैं विधि 1 के आंशिक हूं लेकिन मुझे इनमें से कोई भी विधि थोड़ा दिनांकित मिला है। मैंने सूचियों के माध्यम से लूपिंग के कई उदाहरण देखे हैं और विधि 2 का अधिकतर उपयोग किया जाता है।

तो मेरा सवाल यह है कि बेहतर तरीका क्या है, यदि इन सभी विधियों के बराबर बराबर हैं, तो सबसे मानक क्या है? के रूप में के लिए-प्रत्येक पाश पर्दे के पीछे सूची के इटरेटर का उपयोग करता

private ArrayList<String> list = new ArrayList<String>(); 

public Test() { 
    list.add("One");   
    list.add("Two");   
    list.add("Three");  
    list.add("Four");  
    list.add("Five"); 

    method1(); 
    method2(); 
    method3(); 
} 

public void method1() { 
    System.out.println("Method 1"); 
    int i = 1; 
    for (String value:list) { 
     System.out.println((i++) + " = " + value); 
    } 
} 

public void method2() { 
    System.out.println("Method 2"); 
    for (int i = 0; i < list.size(); i++) { 
     System.out.println((i+1) + " = " + list.get(i)); 
    } 
} 

public void method3() { 
    System.out.println("Method 3"); 
    Iterator<String> it = list.iterator(); 
    int i = 1; 
    while (it.hasNext()) { 
     System.out.println((i++) + " = " + it.next()); 
    } 
} 

Answer 1

method1()method3() के समान है। method3() के साथ अंतर यह है कि आपके पास वास्तव में इस इटरेटर तक पहुंच है, इसलिए यदि आप सूची से तत्वों को हटाना चाहते हैं तो आप इसे हटा सकते हैं।

method2() दूसरी ओर अंतर्निहित कार्यान्वयन के आधार पर "खराब" प्रदर्शन कर सकता है। यदि आपकी सूची LinkedList है, get में O(n) जटिलता समय है तो फॉर-लूप में O(n^2) जटिलता होगी। इटरेटर के साथ, आपको हमेशा निरंतर समय में अगला तत्व मिल जाएगा।

मैं व्यक्तिगत रूप से 1 का उपयोग करता हूं, यह लिखने के लिए भी कम कोड है और यह प्रत्येक लूप के लिए मुख्य लाभ है यदि आपका इरादा आपकी डेटा संरचना पर केवल-पढ़ने के लिए ऑपरेशन करना है।

आप जावा 8 का उपयोग कर रहे हैं और आप सूचकांक मुद्रित करने के लिए की जरूरत नहीं है, तो आप भी कर सकता है:

list.forEach(System.out::println); 

Answer 2

उनमें से कोई भी। यदि जावा < 8.

Answer 3

पहले बेहतर है और कम से कम त्रुटियों की संभावना का उपयोग कर लैम्ब्डा अभिव्यक्ति, जावा 8.

या अमरूद कार्यों में उपलब्ध का उपयोग करें।

public void method1() { 
    System.out.println("Method 1"); 
    int i = 1; 
    for (String value:list) { 
     System.out.println((i++) + " = " + value); 
    } 
} 

दूसरा विकल्प आपके द्वारा उपयोग किए जा रहे संग्रह के साथ कसकर जोड़ दिया गया है। इसका मतलब है, अगर कोई डेटा संरचनाओं को बदलता है तो उसे लूप के लिए भी कोड बदलना होगा।

तीसरा विकल्प, जब आप नेस्टेड लूप का उपयोग करना पड़ता है और एकाधिक इटरेटर से निपटना होता है तो इटरेटर बदसूरत हो सकते हैं।

इटरेटर के त्रुटि प्रवण उपयोग को देखने के लिए निम्न लिंक पर एक नज़र डालें। https://docs.oracle.com/javase/8/docs/technotes/guides/language/foreach.html

Answer 4

method3() जहां Iterator का उपयोग सूची के माध्यम से फिर से करने का सबसे अच्छा तरीका है। भले ही method1() दृश्यों के पीछे Iterator का उपयोग करता है, यदि आप लूप के अंदर सूची को संशोधित करना चाहते हैं, जैसे अद्यतन या हटाएं, तो यह ConcurrentModificationException तक पहुंच सकता है।