एक लूप को बाधित करना

"हाय, अमीगो!

"हाय ऐली।"

"आप पहले ही लूप का अध्ययन कर चुके हैं, और यह अच्छा है।"

"मैं सहमत हूँ! अब मैं पूरी तरह से नहीं जानता कि उनके बिना कैसे रहना है।"

"कभी-कभी आप उनके बिना कर सकते हैं ... लेकिन अधिक बार आपको उनकी आवश्यकता होगी। आज हम उस स्थिति के बारे में बात करने जा रहे हैं जब आपको समय से पहले लूप से बाहर निकलने की आवश्यकता होती है।"

"क्या आपका मतलब है, जब लूप जारी रखने की स्थिति सत्य है, लेकिन आपको अभी भी लूप से बाहर निकलने की जरूरत है?"

"बिल्कुल सही! कभी-कभी आपको लगता है कि आप पहले से ही एक प्रोग्रामर हैं। वैसे भी, शेड्यूल से पहले लूप से बाहर निकलने के लिए, आप ब्रेक स्टेटमेंट का उपयोग कर सकते हैं। निम्नलिखित उदाहरण पर एक नज़र डालें:

Scanner console = new Scanner(System.in);
boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

"मैं देख रहा हूँ। प्रोग्राम कंसोल से लाइनें पढ़ता है। यदि आप प्रवेश करते हैं "exit", तो isExitचर बन जाता है true, लूप की स्थिति होगी , और लूप समाप्त हो जाएगा।"!isExitfalse

"यह सही है। तो, जावा के पास एक विशेष breakकथन है जो आपको इस तरह के तर्क को सरल बनाने देता है। यदि breakएक लूप के अंदर एक बयान निष्पादित किया जाता है, तो लूप तुरंत समाप्त हो जाता है। कार्यक्रम लूप का पालन करने वाले बयान को निष्पादित करना शुरू कर देगा। बयान बहुत संक्षिप्त है :

break;

"यहां बताया गया है कि breakजिस उदाहरण पर हमने अभी चर्चा की है, उसे फिर से लिखने के लिए आप कथन का उपयोग कैसे कर सकते हैं:

Scanner console = new Scanner(System.in);
while (true)
{
   String s = console.nextLine();
   if (s.equals("exit"))
     break;
}

"शायद मुझे वह याद होगा। मुझे लगता है कि यह काम आएगा।"

"लेकिन breakकेवल जावा स्टेटमेंट नहीं है जो आपको लूप के व्यवहार को नियंत्रित करने देता है। जावा में स्टेटमेंट भी है। यदि आप लूप के अंदर continueएक स्टेटमेंट निष्पादित करते हैं , तो लूप का वर्तमान पुनरावृत्ति समय से पहले समाप्त हो जाएगा।"continue

"पुनरावृत्ति से आपका क्या मतलब है?"

"लूप पुनरावृत्ति लूप बॉडी का एक निष्पादन है। continueकथन लूप के वर्तमान पुनरावृत्ति को बाधित करता है, लेकिन breakकथन के विपरीत, यह लूप को स्वयं समाप्त नहीं करता है। कथन भी संक्षिप्त है:

continue;

"तो, continueयदि हम लूप के कुछ पुनरावृत्तियों के निष्पादन को 'छोड़ना' चाहते हैं तो कथन का उपयोग लूप में किया जा सकता है?"

break"बिल्कुल सही। क्या आप और के बीच के अंतर को समझते हैं continue? यदि आपको 20 गैर-दोहराए जाने वाले अंकों में से सात को खोजने की आवश्यकता है, तो आप किस प्रकार के लूप और लूप इंटरप्शन स्टेटमेंट का उपयोग करेंगे?

"ह्म्म्म... मैं सभी संख्याओं को देखूंगा, और अगर मुझे 7 मिल जाए, तो मैं एक निष्पादित करूंगा। break"

"क्या होगा यदि आपको उन संख्याओं को छोड़कर से संख्याओं को प्रदर्शित करने की आवश्यकता है 1जो 20विभाज्य हैं 7?"

"ठीक है, यहाँ मुझे शायद चाहिए continue, क्योंकि मैं लूप से बाहर नहीं निकलना चाहता। लेकिन मैं अभी भी पूरी तरह से समझ नहीं पाया हूँ।"

"मैं आपको दिखाता हूं कि इस समस्या को कैसे हल किया जाए। यह कोड ऐसा दिख सकता है।"

int i = 1;
while (i <= 20)
{
   if ( (i % 7) == 0 )
     continue;
   System.out.println(i);
   i++;
}

"तुम मुझे इतने संदेह से क्यों देख रहे हो, ऐली? क्या यहाँ कुछ पकड़ है?"

"तुम मूर्ख नहीं बन सकते, अमीगो! वास्तव में, यह कोड सही ढंग से काम नहीं करेगा । यह पहले 6 अंक प्रदर्शित करेगा, और फिर iहमेशा के लिए संख्या पर अटका रहेगा 7। आखिरकार, continueकथन दो अन्य कथनों को छोड़ देता है: System.out.println(i)और i++। जैसा कि परिणामस्वरूप, एक बार जब हम मूल्य तक पहुँच जाते हैं 7, तो चर iबदलना बंद हो जाएगा और हम एक अनंत लूप में होंगे। मैंने एक बहुत ही सामान्य गलती को दर्शाने के उद्देश्य से इस तरह से कोड लिखा था।

"हम इसे कैसे ठीक करें?"

"यहाँ दो विकल्प हैं:"

विकल्प 1:i क्रियान्वित करने से पहले बदलें continue, लेकिन बाद मेंi % 7

विकल्प 2:i लूप की शुरुआत में हमेशा वृद्धि करें । लेकिन तब iका प्रारंभिक मूल्य होना चाहिए 0।

int i = 1;
while (i <= 20)
{
   if ( (i % 7) == 0 )
   {
     i++;
     continue;
   }
   
   System.out.println(i);
   i++;
}

int i = 0;
while (i < 20)
{
   i++;
   if ( (i % 7) == 0)
     continue;
   System.out.println(i);
}

"उत्कृष्ट! मैं कोशिश करूँगा कि यह गलती न हो।"

"मैं आपका वादा याद रखूंगा!"