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

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

चक्र जबकि जावा: विवरण और उदाहरण

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

जबकि (हालत) {

// लूप का शरीर

}

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

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

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

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

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

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

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

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

डू-लूप लूप

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

करो {
// लूप का शरीर

} जबकि (हालत);

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

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

जावा चक्र के लिए विवरण और उदाहरण

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

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

बेहतर समझने के लिए, आइए उदाहरण दें कि जावा लूप के लिए कैसे काम करता है:

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

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

के लिए (int i = 1, int j = 10; i <j; ++ i, --j) {}

प्रत्येक पुनरावृत्ति पर, वेरिएबल का मान 1 से बढ़ेगा, और वेरिएबल जे का मान 1 से कम हो जाएगा। पुनरावृत्तियों को निष्पादित किया जाएगा जब तक कि मैं जे से बड़ा या बराबर न हो जाऊं।

कथन के लिए उपयोग करने की विशेषताएं

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

बूलियन निकास = झूठा;

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

बाहर निकलें = सच;

}

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

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

प्रत्येक के लिए शैली में चक्र

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

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

साइकिल इंटरप्ट ऑपरेटर

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

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

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

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

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

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

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

निष्कर्ष

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