दिलचस्प पोस्ट
एएसपी.नेट एमवीसी 3 में किसी विशिष्ट प्रारूप में डेटटाइम कैसे रेंडर करना है? कौन सी सी ++ संकेत / स्लॉट लाइब्रेरी मुझे चुननी चाहिए? Moq फ्रेमवर्क में async टास्क कॉलबैक सेटअप करें प्रारूप में दो बार स्टाम्प की तुलना कैसे करें "महीना दिनांक hh: mm: ss" को + ve या -ve मान की जांच के लिए लम्बाई की सूची में आदिम लम्बे की एक सरणी परिवर्तित करें पायथन में एक सबस्ट्रिंग के सभी संस्करण ढूंढें डेटाफ़्रेम में नमूना यादृच्छिक पंक्तियां जावा थ्रेड में मैं एक पैरामीटर कैसे पास कर सकता हूं? कक्षा com.google.ads.AdView को बढ़ाने में त्रुटि PHP (5.3+) में एक \ (बैकस्लैश) क्या करता है? मैं कैसे जांच करूं यदि कोई वर्ण एक स्वर है? PHP स्क्रिप्ट वास्तव में कैसे निष्पादित है? एक्लिप्स में एक जार कैसे आयात करें एक एम्बेडेड सरणी का उपयोग करते हुए, मेरे रेल बहु-चयन का पहला तत्व हमेशा रिक्त क्यों होता है? अतिव्यापी बिना आयताकारों के एक सेट को कवर करने के लिए सबसे कम आयत खोजने के लिए एल्गोरिथ्म

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

विचार करें:

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

प्रत्येक सिंटैक्स के लिए उपयोग किए बिना पाश के समान क्या दिखता है?

Solutions Collecting From Web of "प्रत्येक 'लूप' काम के लिए जावा कैसे करता है?"

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

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

डेनिस बुएनो द्वारा नोट किया गया था, यह कोड किसी भी ऑब्जेक्ट के लिए काम करता है जो Iterable इंटरफ़ेस लागू करता है ।

इसके अलावा, यदि for (:) मुहावरे के दाहिनी ओर की ओर एक वस्तु के बजाय एक array , तो आंतरिक कोड एक इंडेक्स काउंटर का उपयोग करता है और इसके बजाय array.length विरुद्ध जांच करता है। जावा भाषा विशिष्टता देखें

प्रत्येक के लिए भी सरणियों के लिए वैध है जैसे

 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 () का उपयोग करना है; अपने लूप में, या किसी तरह से वास्तविक इटरेटर का उपयोग करके, आप (:) मुहावरों के लिए उपयोग नहीं कर सकते, क्योंकि वास्तविक इटरेटर केवल अनुमानित है।

[डेनिस बुएनो]

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

यहां एक जवाब है जो जावा इटरेटर के ज्ञान को नहीं मानता है। यह कम सटीक है लेकिन शिक्षा के लिए उपयोगी है।

प्रोग्रामिंग करते समय हम अक्सर कोड लिखते हैं जो निम्न की तरह दिखता है:

 char[] grades = .... for(int i = 0; i < grades.length; i++) { // for i goes from 0 to grades.length System.out.print(grades[i]); // print grades[i] } 

फोरश सिंटैक्स इस सामान्य पैटर्न को अधिक प्राकृतिक और कम वाक्यविन्यास रूप से शोर तरीके से लिखे जाने की अनुमति देता है।

 for(char grade : grades) { // foreach grade in grades System.out.print(grade); // print that grade } 

इसके अतिरिक्त यह वाक्य रचना ऑब्जेक्ट्स जैसे कि सूचियाँ या सेट्स के लिए मान्य है, जो कि सरणी अनुक्रमण का समर्थन नहीं करते हैं, लेकिन जो जावा इटरएबल इंटरफ़ेस को लागू करते हैं।

जावा 5 (जिसे "बढ़ाया गया लूप" भी कहा जाता है) में जोड़ा गया foreach पाश , एक ही बात के लिए java.util.Iterator –it की वाक्यात्मक चीनी का उपयोग करने के बराबर है। इसलिए, प्रत्येक तत्व को पढ़ते समय, एक करके और क्रम में, एक foreach हमेशा एक iterator पर चुना जाना चाहिए, क्योंकि यह अधिक सुविधाजनक और संक्षिप्त है

प्रत्येक के लिए

 for(int i : intList) { System.out.println("An element in the list: " + i); } 

इटरेटर

 Iterator<Integer> intItr = intList.iterator(); while(intItr.hasNext()) { System.out.println("An element in the list: " + intItr.next()); } 

ऐसी स्थितियां हैं जहां आपको सीधे Iterator उपयोग करना चाहिए उदाहरण के लिए, किसी foreach का उपयोग करते हुए एक तत्व को हटाने का प्रयास कर सकते हैं (होगा?) एक ConcurrentModificationException

foreach बनाम: बुनियादी अंतर

के for और foreach बीच एकमात्र व्यावहारिक अंतर यह है कि, सूचक वस्तु के मामले में, आपके पास सूचकांक तक पहुंच नहीं है एक उदाहरण जब पाश के for बुनियादी आवश्यक है:

 for(int i = 0; i < array.length; i++) { if(i < 5) { //Do something special } else { //Do other stuff } } 

यद्यपि आप मैन्युअल रूप से foreach साथ एक अलग सूचकांक int-variable बना सकते हैं

 int idx = -1; for(int i : intArray) { idx++; ... } 

यह अनुशंसित नहीं है, क्योंकि चर-गुंजाइश आदर्श नहीं है, और मूल for लूप केवल इस उपयोग-केस के लिए मानक और अपेक्षित स्वरूप है।

foreach बनाम: प्रदर्शन

संग्रहों तक पहुंचने पर, लूप की सरणी पहुंच के for प्राथमिक से एक foreach काफी तेज है। सरणी तक पहुँचते समय, हालांकि – आदिम और आवरण-एरे के साथ-कम-अनुक्रमित के माध्यम से पहुंच नाटकीय रूप से तेज है

प्रारंभिक अंतर-एरे के लिए इटरेटर और इंडेक्स एक्सेस के बीच अंतर का समय

इंडेक्स या Integer एरेज़ को एक्सेस करते समय इंडेक्स 23 से 40 % तेज़रा से ज्यादा तेज होते हैं। यहां इस पोस्ट के निचले भाग में परीक्षण वर्ग से आउटपुट दिया गया है, जो 100-तत्व आदिम- int सरणी (ए, इटरेटर, बी सूचकांक) में संख्याओं को बताता है:

 [C:\java_code\]java TimeIteratorVsIndexIntArray 1000000 Test A: 358,597,622 nanoseconds Test B: 269,167,681 nanoseconds B faster by 89,429,941 nanoseconds (24.438799231635727% faster) [C:\java_code\]java TimeIteratorVsIndexIntArray 1000000 Test A: 377,461,823 nanoseconds Test B: 278,694,271 nanoseconds B faster by 98,767,552 nanoseconds (25.666236154695838% faster) [C:\java_code\]java TimeIteratorVsIndexIntArray 1000000 Test A: 288,953,495 nanoseconds Test B: 207,050,523 nanoseconds B faster by 81,902,972 nanoseconds (27.844689860906513% faster) [C:\java_code\]java TimeIteratorVsIndexIntArray 1000000 Test A: 375,373,765 nanoseconds Test B: 283,813,875 nanoseconds B faster by 91,559,890 nanoseconds (23.891659337194227% faster) [C:\java_code\]java TimeIteratorVsIndexIntArray 1000000 Test A: 375,790,818 nanoseconds Test B: 220,770,915 nanoseconds B faster by 155,019,903 nanoseconds (40.75164734599769% faster) [C:\java_code\]java TimeIteratorVsIndexIntArray 1000000 Test A: 326,373,762 nanoseconds Test B: 202,555,566 nanoseconds B faster by 123,818,196 nanoseconds (37.437545972215744% faster) 

मैंने यह भी एक Integer सरणी के लिए भाग लिया, और इंडेक्स अभी भी स्पष्ट विजेता हैं, लेकिन केवल 18 से 25 प्रतिशत के बीच तेजी से

संग्रह के लिए, इटरेक्टर अनुक्रमणकों की तुलना में तेज़ हैं

Integers की एक List के लिए, हालांकि, iterators स्पष्ट विजेता हैं बस परीक्षण-कक्षा में इंट-एरे को बदलने के लिए

 List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100}); 

और परीक्षण समारोह में अनिश्चित परिवर्तन ( int[] की List<Integer> , length size() , आदि)

 [C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000 Test A: 3,429,929,976 nanoseconds Test B: 5,262,782,488 nanoseconds A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster) [C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000 Test A: 2,907,391,427 nanoseconds Test B: 3,957,718,459 nanoseconds A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster) [C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000 Test A: 2,566,004,688 nanoseconds Test B: 4,221,746,521 nanoseconds A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster) [C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000 Test A: 2,770,945,276 nanoseconds Test B: 3,829,077,158 nanoseconds A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster) [C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000 Test A: 3,467,474,055 nanoseconds Test B: 5,183,149,104 nanoseconds A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster) [C:\java_code\]java TimeIteratorVsIndexIntList 1000000 Test A: 3,439,983,933 nanoseconds Test B: 3,509,530,312 nanoseconds A faster by 69,546,379 nanoseconds (1.4816434912159906% faster) [C:\java_code\]java TimeIteratorVsIndexIntList 1000000 Test A: 3,451,101,466 nanoseconds Test B: 5,057,979,210 nanoseconds A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster) 

एक परीक्षा में वे लगभग बराबर हैं, लेकिन संग्रह के साथ, इटरेटर जीत जाता है।

यह पोस्ट stackexchange पर मैंने लिखा दो उत्तरों पर आधारित है:

  • https://stackoverflow.com/questions/22110482/uses-and-syntax-for-for-each-loop-in-java/22110517#22110517
  • Should I use an Iterator or a forloop to iterate?

कुछ और जानकारी: Which is more efficient, a for-each loop, or an iterator?

पूर्ण परीक्षण वर्ग

मैंने इस सवाल को stackoverflow पर पढ़ने के बाद यह तुलना-द-टाइम-इसे-ले-टू-टू-किसी-दो-चीज क्लास बनाया था

  import java.text.NumberFormat; import java.util.Locale; /** &lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt; @see &lt;CODE&gt;&lt;A HREF=&quot;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt; **/ public class TimeIteratorVsIndexIntArray { public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US); public static final void main(String[] tryCount_inParamIdx0) { int testCount; //Get try-count from command-line parameter try { testCount = Integer.parseInt(tryCount_inParamIdx0[0]); } catch(ArrayIndexOutOfBoundsException | NumberFormatException x) { throw new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x); } //Test proper...START int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100}; long lStart = System.nanoTime(); for(int i = 0; i < testCount; i++) { testIterator(intArray); } long lADuration = outputGetNanoDuration("A", lStart); lStart = System.nanoTime(); for(int i = 0; i < testCount; i++) { testFor(intArray); } long lBDuration = outputGetNanoDuration("B", lStart); outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B"); } private static final void testIterator(int[] int_array) { int total = 0; for(int i = 0; i < int_array.length; i++) { total += int_array[i]; } } private static final void testFor(int[] int_array) { int total = 0; for(int i : int_array) { total += i; } } //Test proper...END //Timer testing utilities...START public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) { long lDuration = System.nanoTime() - l_nanoStart; System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds"); return lDuration; } public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) { long lDiff = -1; double dPct = -1.0; String sFaster = null; if(l_aDuration > l_bDuration) { lDiff = l_aDuration - l_bDuration; dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5); sFaster = "B"; } else { lDiff = l_bDuration - l_aDuration; dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5); sFaster = "A"; } System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)"); return lDiff; } //Timer testing utilities...END } 

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

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

जावा 8 सुविधाओं में आप इसका उपयोग कर सकते हैं:

 List<String> messages = Arrays.asList("First", "Second", "Third"); void forTest(){ messages.forEach(System.out::println); } 

उत्पादन

 First Second Third 

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

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

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

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

एक अग्रविकल्प पाश वाक्यविन्यास है:

 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 

चेतावनी: आप foreach लूप के साथ सरणी तत्वों तक पहुंच सकते हैं, लेकिन उन्हें प्रारंभ नहीं कर सकते। इसके लिए लूप के लिए मूल का उपयोग करें
चेतावनी: आपको अन्य ऑब्जेक्ट के साथ सरणी के प्रकार से मेल खाना चाहिए।

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

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

 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 

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

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

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

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

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

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

  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); 
 for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) { String item = itr.next(); System.out.println(item); } 

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

 for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) { System.out.println(sit.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> i = someList.iterator(); i.hasNext(); ) System.out.println(i.next()); 

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

इतने सारे अच्छे उत्तर के रूप में, एक ऑब्जेक्ट को Iterable interface को लागू करना चाहिए यदि वह for-each लूप का उपयोग करना चाहता है।

मैं एक सरल उदाहरण पोस्ट करूँगा और एक अलग तरीके से समझाने की कोशिश करूँगा कि for-each लूप कैसे काम करता है

for-each लूप का उदाहरण:

 public class ForEachTest { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("111"); list.add("222"); for (String str : list) { System.out.println(str); } } } 

फिर, अगर हम इस वर्ग को javap करने के लिए javap का इस्तेमाल करते हैं, तो हम इस बाइटकोड नमूना प्राप्त करेंगे:

 public static void main(java.lang.String[]); flags: ACC_PUBLIC, ACC_STATIC Code: stack=2, locals=4, args_size=1 0: new #16 // class java/util/ArrayList 3: dup 4: invokespecial #18 // Method java/util/ArrayList."<init>":()V 7: astore_1 8: aload_1 9: ldc #19 // String 111 11: invokeinterface #21, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z 16: pop 17: aload_1 18: ldc #27 // String 222 20: invokeinterface #21, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z 25: pop 26: aload_1 27: invokeinterface #29, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator; 

जैसा कि हम नमूना की अंतिम पंक्ति से देख सकते हैं, कंपाइलर स्वत for-each समय के लिए Iterator समय पर एक Iterator के उपयोग के for-each उपयोग को रूपांतरित कर देगा। यह समझा जा सकता है कि ऑब्जेक्ट, जो Iterable interface लागू नहीं करता Iterable interface , जब for-each लूप का उपयोग करने का प्रयास करता है तो एक Exception फेंकता होगा।

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

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

वेरिएन 1 (सादे):

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

वेरिएंट 2 (समानांतर निष्पादन (तेज़)):

 someList.parallelStream().forEach(listItem -> { System.out.println(listItem); }); 
 public static Boolean Add_Tag(int totalsize) { List<String> fullst = new ArrayList<String>(); for(int k=0;k<totalsize;k++) { fullst.addAll(); } } 

हर मुहावरे के लिए जावा केवल एरेज़ या ऑब्जेक्ट प्रकार * इटेरेबल पर लागू किया जा सकता है। यह मुहावर निहित है क्योंकि यह वास्तव में एक इटरेटर द्वारा समर्थित है I इटरेटर प्रोग्रामर द्वारा क्रमादेशित है और अक्सर अपनी स्थिति का ट्रैक रखने के लिए एक पूर्णांक सूचकांक या नोड (डेटा संरचना के आधार पर) का उपयोग करता है। कागज पर यह नियमित रूप से लूप के मुकाबले धीमी है, कम से कम "रैखिक" संरचनाओं जैसे कि सरणियों और सूचियों के लिए, लेकिन यह अधिकतर अमूर्तता प्रदान करता है