java - प्रत्येक 'लूप के लिए जावा' कैसे काम करता है?




foreach syntactic-sugar (16)

अपने "प्रत्येक के लिए" से बचने के लिए प्रत्येक के लिए एक विकल्प:

List<String> someList = new ArrayList<String>();

संस्करण 1 (सादा):

someList.stream().forEach(listItem -> {
    System.out.println(listItem);
});

संस्करण 2 (समानांतर निष्पादन (तेज़)):

someList.parallelStream().forEach(listItem -> {
    System.out.println(listItem);
});

विचार करें:

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
    System.out.println(item);
}

प्रत्येक वाक्यविन्यास के उपयोग के बिना लूप के बराबर क्या दिखता है?


एक foreach पाश वाक्यविन्यास है:

for (type obj:array) {...}

उदाहरण:

String[] s = {"Java", "Coffe", "Is", "Cool"};
for (String str:s /*s is the array*/) {
    System.out.println(str);
}

आउटपुट:

Java
Coffe
Is
Cool

चेतावनी: आप फोरैच लूप के साथ सरणी तत्वों तक पहुंच सकते हैं, लेकिन आप उन्हें प्रारंभ नहीं कर सकते हैं। उस के for लूप के लिए मूल का प्रयोग करें।

चेतावनी: आपको अन्य ऑब्जेक्ट के साथ सरणी के प्रकार से मेल खाना चाहिए।

for (double b:s) // Invalid-double is not String

यदि आप तत्वों को संपादित करना चाहते हैं, तो इस तरह for लूप के for मूल का उपयोग करें:

for (int i = 0; i < s.length-1 /*-1 because of the 0 index */; i++) {
    if (i==1) //1 because once again I say the 0 index
        s[i]="2 is cool";
    else
        s[i] = "hello";
}

अब अगर हम कंसोल पर डंप करते हैं, तो हमें मिलता है:

hello
2 is cool
hello
hello

जावा "फॉर-प्रत्येक" लूप निर्माण दो प्रकार की वस्तुओं पर पुनरावृत्ति की अनुमति देगा:

  • T[] (किसी भी प्रकार के सरणी)
  • java.lang.Iterable<T>

Iterable<T> इंटरफ़ेस में केवल एक विधि है: Iterator<T> iterator() । यह Collection<T> की वस्तुओं पर काम करता है क्योंकि Collection<T> इंटरफ़ेस Iterable<T> बढ़ाता है।


जावा 8 फीचर्स में आप इसका उपयोग कर सकते हैं:

List<String> messages = Arrays.asList("First", "Second", "Third");

void forTest(){
    messages.forEach(System.out::println);
}

उत्पादन

First
Second
Third

जावा में प्रत्येक लूप अंतर्निहित इटरेटर तंत्र का उपयोग करता है। तो यह निम्नलिखित के समान है:

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
  String item = iterator.next();
  System.out.println(item);
}

जैसा कि प्रत्येक लूप के लिए जेएलएस में परिभाषित किया गया है, दो रूप हो सकते हैं:

  1. यदि अभिव्यक्ति का प्रकार Iterable उप-प्रकार है तो अनुवाद इस प्रकार है:

    List<String> someList = new ArrayList<String>();
    someList.add("Apple");
    someList.add("Ball");
    for (String item : someList) {
        System.out.println(item);
    }
    
    // IS TRANSLATED TO:
    
    for(Iterator<String> stringIterator = someList.iterator(); stringIterator.hasNext(); ) {
        String item = stringIterator.next();
        System.out.println(item);
    }
    
  2. अगर अभिव्यक्ति के पास एक सरणी प्रकार T[] तो:

    String[] someArray = new String[2];
    someArray[0] = "Apple";
    someArray[1] = "Ball";
    
    for(String item2 : someArray) {
        System.out.println(item2);
    }
    
    // IS TRANSLATED TO:
    for (int i = 0; i < someArray.length; i++) {
        String item2 = someArray[i];
        System.out.println(item2);
    }
    

जावा 8 ने धाराओं को पेश किया है जो आम तौर पर बेहतर प्रदर्शन करते हैं। हम उनका उपयोग इस प्रकार कर सकते हैं:

someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);

यह nsayer के उत्तर से निहित है, लेकिन यह ध्यान देने योग्य है कि ओपी का (..) वाक्यविन्यास काम करेगा जब " कुछ सूची " कुछ भी है जो java.lang लागू करता है। अक्षम - इसे एक सूची, या कुछ संग्रह नहीं होना चाहिए java.util। इसलिए, अपने स्वयं के प्रकार भी इस वाक्यविन्यास के साथ उपयोग किया जा सकता है।


यह ऐसा कुछ दिखता है। बहुत क्रूर

for (Iterator<String> i = someList.iterator(); i.hasNext(); )
        System.out.println(i.next());

सूर्य प्रलेखन में प्रत्येक के लिए एक अच्छा लेखन है।


यह भी ध्यान रखें कि मूल प्रश्न में "foreach" विधि का उपयोग करने से कुछ सीमाएं होती हैं, जैसे कि पुनरावृत्ति के दौरान सूची से आइटम को निकालने में सक्षम नहीं है।

नया फॉर-लूप एक अलग इटरेटर की आवश्यकता को पढ़ने और हटाने के लिए आसान है, लेकिन केवल पढ़ने-योग्य पुनरावृत्ति पास में ही वास्तव में प्रयोग योग्य है।


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

लूप के for सामान्य:

void cancelAll(Collection<TimerTask> list) {
    for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
         i.next().cancel();
}

प्रत्येक के लिए उपयोग करना:

void cancelAll(Collection<TimerTask> list) {
    for (TimerTask t : list)
        t.cancel();
}

प्रत्येक के लिए एक संग्रह पर एक निर्माण है जो इटरेटर लागू करता है। याद रखें कि, आपके संग्रह को इटरेटर लागू करना चाहिए; अन्यथा आप इसे प्रत्येक के साथ उपयोग नहीं कर सकते हैं।

निम्नलिखित पंक्ति को " सूची में प्रत्येक टाइमरटास्क टी के लिए " के रूप में पढ़ा जाता है

for (TimerTask t : list)

प्रत्येक के मामले में त्रुटियों के लिए कम मौका है। आपको इटरेटर को प्रारंभ करने या लूप काउंटर को प्रारंभ करने और इसे समाप्त करने के बारे में चिंता करने की आवश्यकता नहीं है (जहां त्रुटियों के लिए दायरा है)।


यहां एक समकक्ष अभिव्यक्ति है।

for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
    System.out.println(sit.next());
}

विकिपीडिया में उल्लिखित एक foreach पाश की अवधारणा नीचे हाइलाइट किया गया है:

लूप संरचनाओं के लिए अन्य के विपरीत, हालांकि, फोरच लूप आमतौर पर कोई स्पष्ट काउंटर नहीं बनाए रखते हैं: वे अनिवार्य रूप से "इस एक्स बार में" करने के बजाय "इस सेट में सब कुछ करने के लिए" कहें। यह संभावित ऑफ-बाय-वन त्रुटियों से बचाता है और कोड को पढ़ने के लिए सरल बनाता है।

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

// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++){

}

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


प्रत्येक के लिए निर्माण सरणी के लिए भी मान्य है। जैसे

String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };

for (String fruit : fruits) {
    // fruit is an element of the `fruits` array.
}

जो अनिवार्य रूप से बराबर है

for (int i = 0; i < fruits.length; i++) {
    String fruit = fruits[i];
    // fruit is an element of the `fruits` array.
}

तो, कुल सारांश:
[nsayer] क्या हो रहा है का लंबा रूप निम्नलिखित है:

for(Iterator<String> i = someList.iterator(); i.hasNext(); ) {
  String item = i.next();
  System.out.println(item);
}

ध्यान दें कि यदि आपको i.remove () का उपयोग करने की आवश्यकता है; अपने लूप में, या वास्तविक इटरेटर को किसी भी तरह से एक्सेस करें, आप (:) idiom का उपयोग नहीं कर सकते हैं, क्योंकि वास्तविक इटरेटर केवल अनुमानित है।

[डेनिस Bueno]

यह nsayer के उत्तर से निहित है, लेकिन यह ध्यान देने योग्य है कि ओपी का (..) वाक्यविन्यास काम करेगा जब "कुछ सूची" कुछ भी है जो java.lang लागू करता है। अक्षम - इसे एक सूची, या कुछ संग्रह नहीं होना चाहिए java.util। इसलिए, अपने स्वयं के प्रकार भी इस वाक्यविन्यास के साथ उपयोग किया जा सकता है।


List<Item> Items = obj.getItems();
for(Item item:Items)
             {
                System.out.println(item); 
             }

आइटम तालिका में सभी वस्तुओं पर Iterates।


for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
   String item = itr.next();
   System.out.println(item);
}

public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}




syntactic-sugar