(जावा) लूप के लिए अनंत

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

जावा लूप जबकि: विवरण और उदाहरण

जावा में मौलिक लूप ऑपरेटर हैजबकि। इसके शरीर में संलग्न कोड खंड को दोहराया जाएगा जब तक कि यह सत्य के तार्किक मूल्य को संतुष्ट करने के बाद कोष्ठक में अभिव्यक्त अभिव्यक्ति की स्थिति को दोहराया जाता है। निम्न कथन का सामान्य रूप इस प्रकार है:

जबकि (स्थिति) {

// चक्र का शरीर

}

जैसे ही तार्किक स्थिति का मूल्य सत्य हो जाता है, लूप के शरीर में संलग्न कोड निष्पादित करना बंद कर देगा और इसके तुरंत बाद नियंत्रण रेखा पर स्थानांतरित हो जाएगा।

स्पष्टता के लिए, आइए नीचे दिए गए चित्र में दिखाए गए उदाहरण को देखें:

घोषित चर संख्या शुरू में हैमान 1. अगला, हम ऑपरेटर के नाम के बाद कोष्ठक में संलग्न एक बूलियन अभिव्यक्ति देखते हैं। यह सच होगा, अर्थात् जब तक गणना चर का मान 10 से कम या बराबर न हो, तब तक लौटें। लूप के शरीर में, प्रत्येक पास (पुनरावृत्ति) के साथ, चर का मान 1 से बढ़ जाता है और कंसोल स्क्रीन पर प्रदर्शित होता है। ध्यान दें कि जब चर 11 तक पहुंच गया, तो लूप चलना बंद हो गया।

यदि शुरू में चर गणना का मान 11 के बराबर था, तो लूप की स्थिति झूठी होगी, और कार्यक्रम उसके शरीर में भी प्रवेश नहीं करेगा।

यह ध्यान देने योग्य है कि जावा सिंटैक्स अनुमति देता हैशरीर के बिना थोड़ी देर के बयान का उपयोग करें। चलिए एक उदाहरण देते हैं। मान लें कि हमारे पास दो चर i = 100 और j = 200 हैं, हमें उनके अंकगणितीय माध्य प्रोग्राम की गणना करने के कार्य के साथ सामना करना पड़ रहा है - इसके लिए आप "खोखले" का उपयोग कर सकते हैं:

जबकि (++ i <- j);

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

करते-करते पाश

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

करना {
// चक्र का शरीर

} जबकि (स्थिति);

जैसा कि हम देख सकते हैं, पहले लूप का शरीर निष्पादन में जाता है, और उसके बाद ही स्थिति की सच्चाई की जाँच की जाती है - और इसी तरह हर पुनरावृत्ति पर।

ऊपर दिया गया कोड कुछ इस तरह से काम करेगानियमित समय के मामले में भी ऐसा ही है। हालाँकि, अगर हमने वैरिएबल काउंट को 11 मान दिया है, तो लूप की बॉडी को एक्‍सप्रेशन को सही साबित करने के लिए ऑपरेटर के परीक्षण से पहले एक बार निष्पादित किया जाएगा।

विवरण और उदाहरण के लिए - जावा लूप

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

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

एक बेहतर समझ के लिए, यहाँ एक उदाहरण है कि जावा लूप कैसे काम करता है:

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

ऐसे हालात हैं जब आपको घोषित करने की आवश्यकता होती हैलूप को नियंत्रित करने वाले कई चर। जावा के लिए, एक लूप आपको कॉमा द्वारा अलग किए गए दो या अधिक चर को निर्दिष्ट करने की अनुमति देता है, और यह उनके प्रारंभ के दौरान और दूसरे प्रवाह के दौरान किया जा सकता है। इस तरह के एक ऑपरेटर इस तरह दिखेगा:

for (int i = 1, int j = 10; मैं <j; ++ i, --j) {}

प्रत्येक पुनरावृत्ति पर, चर I का मान 1 से बढ़ जाएगा, और चर j का मान 1. घट जाएगा। पुनरावृत्तियों तब तक प्रदर्शन किया जाएगा जब तक कि मैं j से बड़ा या बराबर नहीं हो जाता।

ऑपरेटर के लिए उपयोग करने की विशिष्टता

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

बूलियन निकास = गलत;

(int i = 0;? बाहर निकलें; ++ i) {

निकास = सत्य;

}

ऊपर दिए गए उदाहरण में, हम देख सकते हैं कि कैसे काम करते हैंलूप नियंत्रण चर i से बिल्कुल स्वतंत्र है और पुनरावृत्तियों की संख्या केवल उस क्षण पर निर्भर करती है जिस पर चर निकास सही हो जाता है। इसके अलावा, नियंत्रण चर को पूरी तरह से लूप से हटाया जा सकता है और यह किसी भी तरह से इसके संचालन को प्रभावित नहीं करेगा: के लिए ((बाहर निकलें;) {}। जबकि कार्यक्रम का सबसे आसान तरीका नहीं है, यह कई बार उपयोगी हो सकता है। मुख्य चीज ऐसी स्थिति के लिए प्रदान करना है जिसमें चर लूप से बाहर निकलने के लिए आवश्यक मूल्य लेगा, ताकि इसे अनंत में बदल न जाए।

जावा के लिए, एक लूप को इस तरह से घोषित किया जा सकता हैरास्ता: के लिए (;;) {}। यह विशेष रुकावट स्थितियों के साथ एक अनंत लूप का एक विशिष्ट उदाहरण है। हम इस बारे में बात करेंगे कि इस तरह के चक्रों को थोड़ी देर बाद कैसे बाधित किया जाए।

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

जावा फ़ॉरच लूप हमेशा लागू होता हैकिसी सरणी या किसी डेटा संरचना के तत्वों की क्रमिक गणना और उन पर कुछ दोहराए जाने वाले संचालन करना। कथन के इस रूप का एक उदाहरण नीचे दिखाया गया है:

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

बाधित लूप ऑपरेटर

तीन लूप अवरोध कथन हैं:तोड़ो, लौटो और जारी रखो। पहले दो लूप के काम को पूरी तरह से बाधित करने में सक्षम हैं, जबकि जारी चलना केवल वर्तमान पुनरावृत्ति के काम को बाधित करता है। यदि आप जानबूझकर अपने कोड में एक अनंत जावा लूप का उपयोग करते हैं, तो ये ऑपरेटर इसमें मौजूद होने चाहिए। आइए ब्रेक का उपयोग करने का एक सरल उदाहरण देखें:

यद्यपि यह कथन के लिए 11 पुनरावृत्तियों प्रदान करता है, केवल 8 को निष्पादित किया जाएगा, क्योंकि जब मैं काउंटर 7 होगा, तो स्थिति को ट्रिगर किया जाएगा, जिसके शरीर में एक ब्रेक स्टेटमेंट है।

रिटर्न स्टेटमेंट एक समान तरीके से काम करता है, इस अंतर के साथ कि यह न केवल जावा लूप से बाहर निकलता है, बल्कि उस विधि से भी बाहर निकलता है जिसमें लूप रखा गया है।

एक गोटो के रूप में ब्रेक का उपयोग करना

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

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

कोड एक लेबल के नाम के साथ तीन ब्लॉक घोषित करता है,दो और तीन, क्रमशः। दो का लेबल वाला ब्रेक स्टेटमेंट सभी तीन ब्लॉकों में निहित है, लेकिन जब ट्रिगर किया जाता है, तो प्रोग्राम तीन और दो ब्लॉकों से बाहर निकल जाएगा और वन ब्लॉक में निष्पादन जारी रखेगा। उन। हम कंसोल में दो संदेश देखेंगे: तीन और एक।

निष्कर्ष

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