जावा फॉर लूप

एक बार मार्क जुकरबर्ग ने नोट किया था कि कमांड की पुनरावृत्ति में कंप्यूटर वास्तव में अच्छे हैं। मनुष्य के लिए यह आसान नहीं है, हम एक ही चीज़ को लगातार कई बार दोहरा कर थक चुके हैं, लेकिन एक कंप्यूटर इसे लाखों और अरबों बार कर सकता है और कभी भी ऊबता नहीं है। यदि आप सभी फेसबुक उपयोगकर्ताओं को बधाई भेजने का प्रयास करते हैं, तो ऐसा करने के लिए पर्याप्त दिनों के लिए कोई इंसान नहीं है। हालाँकि आप कोड की कुछ पंक्तियाँ लिखकर इस कार्य को हल करने के लिए एक कंप्यूटर बना सकते हैं। इस तरह लूप काम करते हैं। वे हमें उसी नियमित क्रिया को दोहराने नहीं देते हैं। जावा में सबसे लोकप्रिय लूप तथाकथित परिभाषित लूप या लूप के लिए है।

जावा में लूप के लिए कैसे लिखें? सामान्य रूप से पाश के लिए

लूप के लिए कुछ कथनों को एक निश्चित संख्या में निष्पादित किया जाता है। उदाहरण के लिए, पचास बार "मुझे ऐसा नहीं होना चाहिए, हो-हो, हो" लिखना या अपने सभी दोस्तों को निमंत्रण भेजना इस तरह के लूप के विशिष्ट कार्य हैं। for लूप के सबसे सामान्य संस्करण का सिंटैक्स:

for ([counter initialization]; [checking conditions]; [changing of the counter])
{
    //  statements
}

इनिशियलाइज़ेशन एक्सप्रेशन को एक बार निष्पादित किया जाता है, फिर स्थिति का मूल्यांकन किया जाता है, जो एक बूलियन एक्सप्रेशन होना चाहिए।

जब लूप शुरू होता है तो इनिशियलाइज़ेशन निष्पादित होता है।
जब स्थितियाँ असत्य का मूल्यांकन करती हैं, तो हमारा लूप अपना काम करना बंद कर देता है।

काउंटर बदल रहा है, आमतौर पर लूप के माध्यम से प्रत्येक पुनरावृत्ति के बाद वृद्धि (या कमी) होती है। आप तीन लूप एक्सप्रेशन (इनिशियलाइज़ेशन, चेकिंग कंडीशन, काउंटर को बदलना) में से किसी को भी छोड़ सकते हैं। लूप के अगले चरण से पहले लूप की स्थिति की जाँच की जाती है। यदि स्थिति गलत है, तो प्रोग्राम लूप से बाहर चला जाता है और निर्माण के लिए निर्देशों का पालन करना जारी रखता है। यहाँ हमारे पास for लूप का ब्लॉक डायग्राम है। जावा में लूप के लिए - 2

जावा में लूप के लिए उपयोग कैसे करें। सरल उदाहरण।

यहाँ लूप उदाहरण के लिए एक विशेष जावा है। चलो दस बार लिखते हैं "हैलो!" String हर बार यह नई लाइन से इस लाइन की संख्या के साथ होगा। हमें अगला आउटपुट मिलना चाहिए:

नमस्ते!
नमस्ते!
नमस्ते!
नमस्ते!
नमस्ते!
नमस्ते!
नमस्ते!
नमस्ते!
नमस्ते!
नमस्ते!

यहाँ हमारा जावा प्रोग्राम है जो इस समस्या को हल करता है:

public class ForExample {
   public static void main(String[] args) {
       for (int i = 0; i < 10; i++) {
           System.out.println(i + 1 + ". Hello!");
       }
   }
}

यह काम किस प्रकार करता है?

चरण 1. काउंटर i = 0. लूप हमारी स्थिति की जाँच करता है, i << 10, इसलिए, लूप स्टेटमेंट निष्पादित होते हैं। यह "1. हैलो!" वाक्यांश को प्रिंट करता है। 1 एक स्ट्रिंग i + 1 है (क्योंकि हम शून्य से गिने जाते हैं, लेकिन पहली पंक्ति अभी भी पहली है)। काउंटर i बढ़ा दिया गया है। अब, i = 1. चरण 2. काउंटर i = 1. i < 10, तो हमारे पास एक वाक्यांश है "2. नमस्कार!" और i + 1 = 2. … चरण 10. काउंटर i = 9, हमें "10. हैलो!" और i को 10. चरण 11. काउंटर i = 10. i < 10 तक बढ़ा दिया गया है? नहीं, यह असत्य है। इसलिए, लूप समाप्त हो गया है। जावा में लूप के लिए - 3

जबकि लूप और लूप के लिए: अंतर और समानताएं

जावा में अनिश्चितकालीन लूप या जब बूलियन स्थिति सही होने पर लूप को लगातार निष्पादित किया जाता है। जबकि लूप का सिंटैक्स:

while (boolean condition)
       {
            loop statements...
       }

बहुत बार आप चुन सकते हैं कि आप किस लूप का उपयोग करना चाहते हैं। कभी-कभी वे बहुत करीब होते हैं और आप दोनों का उपयोग कर सकते हैं। उदाहरण के लिए, यहाँ एक ही कार्य के लिए कोड है (कई पंक्तियों के साथ दस बार "हैलो!" लिखकर) जबकि लूप के साथ लिखा गया है:

public class ForAndForEach {
   public static void main(String[] args) {
       int j = 0;  //  we use the counter this way
       while (j < 10) {
           System.out.println(j + 1 + ". Hello!");
           j++;
       }
   }
}

हालाँकि, पेशेवर प्रोग्रामर वास्तव में लूप को पसंद नहीं करते हैं, और जहाँ भी संभव हो, लूप के लिए उपयोग करने का प्रयास करें।

के लिए जबकि

यदि हम पहले से ही पुनरावृत्तियों की संख्या जानते हैं तो हम for लूप का उपयोग करते हैं।

यदि हम पुनरावृत्तियों की ठीक-ठीक संख्या नहीं जानते हैं, तो हम while लूप का उपयोग करते हैं।

इनिशियलाइज़ेशन, कंडीशन चेकिंग और काउंटर चेंजिंग पहले से ही एक लूप के सिंटैक्स में सिले हुए हैं

लूप के अंदर इनिशियलाइज़ेशन और कंडीशन चेकिंग। आप बयानों में अतिरिक्त रूप से काउंटर का उपयोग कर सकते हैं।

इसके लिए अनंत लूप:

for(;;){
	System.out.println("working...");
}

अनंत लूप जबकि:

while(true){
	System.out.println("working...");
}

जावा में लूप के लिए कैसे बाहर निकलें

आम तौर पर लूप के लिए प्रवाह की तरह चल रहा है और लूप से बाहर निकलने का प्राकृतिक तरीका तब होता है जब कोई शर्त झूठी मान लेती है। हालाँकि, दो नियंत्रण कथन हैं जो आपको किसी शर्त का गलत मान प्राप्त करने से पहले लूप से बाहर निकलने की अनुमति देते हैं — तोड़ें और जारी रखें।

ब्रेक वर्तमान लूप बॉडी से बाहर निकलने की अनुमति देता है जैसे कि लूप की स्थिति का मूल्यांकन गलत है।
जारी रखें बयानों को निष्पादित किए बिना लूप को अगले चरण (काउंटर को दोहराते हुए) पर कूदने के लिए बनाता है।

आइए ब्रेक और जारी रखें का उपयोग करके अगली समस्या हल करें। हमारे पास नामों की एक श्रृंखला है और हम अजनबियों को छोड़कर इस सरणी से सभी को नमस्ते कहते हैं। इसलिए यदि हम अपने पाश के दौरान एक "अजनबी" स्ट्रिंग से मिलते हैं तो हम उससे बाहर निकल जाते हैं (चले जाते हैं और किसी और को नमस्ते कहना बंद कर देते हैं)।

public class ForBreakExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
//  how to break out of a for loop, java: check if we have any "Stranger" in  //  our array
if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               break;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

हमारे कार्यक्रम के निष्पादन का परिणाम है:

Hello,Mike
Hello,Dustin
I don't chat with strangers

देखना? लुकास और विल का अभिवादन करने से पहले हम लूप से भाग गए। अब एक "अजनबी" को अनदेखा करने के लिए जारी रखें का उपयोग करें, लेकिन अन्य मित्रों को नमस्ते कहने के लिए लूप के अंदर रहें।

public class ForContinueExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
           if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

परिणाम है:

Hello,Mike
Hello,Dustin
I don't chat with strangers
Hello,Lucas
Hello,Will

उत्कृष्ट! हमने सभी दोस्तों का अभिवादन किया, लेकिन किसी अजनबी से बात नहीं की।

for लूप या for-प्रत्येक का उन्नत संस्करण

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

for (type itVar: array)
{
    Block of operators;
}

जहाँ प्रकार पुनरावृत्त चर का प्रकार है (सरणी के डेटा प्रकार के समान), ItVar इसका नाम है, सरणी सरणी है या कोई अन्य डेटा संरचना हो सकती है, उदाहरण के लिए, ArrayList। जैसा कि आप देख सकते हैं, कोई काउंटर नहीं है, पुनरावृत्ति चर किसी सरणी या संग्रह के तत्वों पर पुनरावृति करता है, न कि सूचकांक मानों पर। जब इस तरह के लूप को निष्पादित किया जाता है, तो पुनरावृति चर को क्रमिक रूप से सरणी या संग्रह के प्रत्येक तत्व का मान दिया जाता है, जिसके बाद बयानों के निर्दिष्ट ब्लॉक (या ऑपरेटर) को निष्पादित किया जाता है। ध्यान दें: for-प्रत्येक लूप को सरणियों और java.lang.Iterable इंटरफ़ेस को लागू करने वाले किसी भी वर्ग पर लागू किया जा सकता है। आइए अजनबियों ("अजनबी") को अनदेखा करते हुए अभिवादन मित्रों के साथ एक ही समस्या का समाधान करें, लेकिन इस बार for-प्रत्येक लूप का उपयोग करें।

public class ForEachExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
	//  for each loop, Java code
       for (String name : names) {
           if (name.equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("hello, " + name);
       }
   }
}

आपने जो सीखा है उसे सुदृढ़ करने के लिए, हमारा सुझाव है कि आप हमारे जावा कोर्स से एक वीडियो सबक देखें

अधिक पढ़ना:
जावा नेस्टेड लूप्स प्रत्येक पाश के लिए