(जावा) लूप्स। पैरामीटर के साथ लूप (के लिए)

एक ऐसी स्थिति की कल्पना करें जहां हमें एक ही शब्द को स्क्रीन पर प्रदर्शित करने की आवश्यकता है, आइए "HELLO" शब्द को 10 बार कहें। हमें क्या करना चाहिए?
आप 10 बार cout << कमांड ले और लिख सकते हैं। "नमस्कार";

लेकिन क्या होगा अगर आपको 10 बार नहीं, बल्कि 20, 30, 40 बार और अगर 200 बार चाहिए? ऐसे में नकल में काफी समय लगेगा। और यदि उपयोगकर्ता के लिए यह चुनना आवश्यक है कि स्क्रीन पर कितनी बार जानकारी प्रदर्शित करनी है? 

इस कार्य से निपटने के लिए LOOP
नामक एक विशेष निर्माण हमारी मदद करेगा
लूप एक एल्गोरिथम निर्माण है जिसमें कमांड का एक निश्चित क्रम कई बार दोहराया जाता है।

जावा प्रोग्रामिंग भाषा में, दो प्रकार के लूप होते हैं: एक चर के साथ एक लूप (के लिए) और एक लूप एक शर्त के साथ (जबकि और करो...जबकि)

चलिए पहले प्रकार से साइकिल से परिचित होना शुरू करते हैं।

एक चर के साथ लूप या चरणों की ज्ञात संख्या के साथ (FOR)

अक्सर ऐसा होता है कि हम कुछ क्रियाओं की पुनरावृत्ति की संख्या जानते हैं, या हम ज्ञात डेटा का उपयोग करके दोहराव की संख्या की गणना कर सकते हैं। कुछ प्रोग्रामिंग भाषाओं में एक कमांड होता है जो रूसी में REPEAT (कई बार की संख्या) जैसा लगता है - यानी, हम दोहराव की सटीक संख्या निर्दिष्ट कर सकते हैं। 

यह देखना दिलचस्प है कि यह चक्र मशीन स्तर पर कैसे काम करता है:
1. एक निश्चित मेमोरी सेल को मेमोरी में आवंटित किया जाता है और उसमें दोहराव की संख्या लिखी जाती है,
2. जब प्रोग्राम लूप बॉडी को एक बार निष्पादित करता है, तो इस सेल (काउंटर) की सामग्री एक से कम हो जाती है।
3. इस सेल के शून्य होने पर लूप निष्पादन समाप्त हो जाता है।

जावा प्रोग्रामिंग भाषा में, ऐसा कोई निर्माण नहीं है, लेकिन निर्माण के लिए।  

for लूप स्टेटमेंट का सामान्य रूप इस प्रकार है: <पूर्व> <कोड> के लिए (/*अभिव्यक्ति1*/; /*अभिव्यक्ति2*/; /*अभिव्यक्ति3*/ ) { /*एक स्टेटमेंट या स्टेटमेंट का ब्लॉक - लूप बॉडी*/; } इस निर्माण के लिए आवश्यक है कि हम
1. स्पष्ट रूप से एक मेमोरी सेल आवंटित करें, जो एक काउंटर होगा, और इसका प्रारंभिक मान सेट करें
2. एक शर्त लिखी थी जिसके तहत साइकिल की बॉडी को अंजाम दिया जाएगा
3. इंगित करें कि इस सेल में मान कैसे बदलेगा।

व्यावहारिक भाग में, हम हैलो शब्द को 10 बार प्रदर्शित करने का प्रयास करेंगे। निम्नलिखित कार्यों में, हम इस निर्माण का अधिक विस्तार से विश्लेषण करेंगे।

अभिव्यक्ति 1

चक्र चर (काउंटर) के प्रारंभिक मान को सेट करने के लिए जिम्मेदार, अर्धविराम
के साथ समाप्त होता है उदाहरण के लिए : <पूर्व> विकल्प 1) मैं = 0; // चक्र चर i को शून्य के बराबर प्रारंभिक मान दिया गया है। इस तरह के रिकॉर्ड के साथ, // चर i को लूप से पहले घोषित किया जाना चाहिए विकल्प 2) int i=0; // वेरिएबल i को साइकिल हेडर में तुरंत घोषित किया जा सकता है, लेकिन // इस मामले में, लूप के बाद स्मृति से मिटा दिया जाएगा विकल्प 3); // कोई आरंभीकरण और चक्र चर की घोषणा बिल्कुल नहीं, // इस मामले में इसे लूप से पहले घोषित किया जा सकता है अभिव्यक्ति 2 <पूर्व> यह  लूप को जारी रखने की शर्त है, इसकी सत्यता के लिए जाँच की जाती है। i<=10 // लूप तब तक चलेगा जब तक i 10 से कम या उसके बराबर है। शर्त कुछ भी हो सकती है अभिव्यक्ति 3  <पूर्व> काउंटर चर का मान बदलता है। इस मान के बिना, लूप को अनंत माना जाएगा i<=10 // लूप तब तक चलेगा जब तक i 10 से कम या उसके बराबर है। शर्त कुछ भी हो सकती है आइए लूप के लिए शीर्षक लिखने का अभ्यास करें

<पूर्व> के लिए (मैं = 0; मैं < 10; मैं ++) {...} //मानक शीर्षक <पूर्व> for (i = 0, x = 1.; i < 10; i += 2, x *= 0.1){...} // इस मामले में, हम दो वेरिएबल्स का उपयोग करते हैं जो लूप बॉडी के निष्पादन के बाद बदल जाएंगे - ये वेरिएबल्स i और x हैं // चर i चरण 2 के साथ बदलता है - i+=2 - i=i+2 के लिए आशुलिपि // चर x प्रत्येक चरण के साथ 0.1 गुना बढ़ जाता है x=x*0.1 - संक्षिप्त रूप में x*=0.1

for लूप वाले सभी प्रोग्राम जिन्हें हमने अभी तक लिखा है उन्हें यूनिवर्सल नहीं कहा जा सकता है। क्योंकि हम लूप बॉडी के दोहराव की संख्या स्वयं निर्धारित करते हैं। 
लेकिन क्या होगा अगर दोहराव की संख्या किसी अन्य मूल्य पर निर्भर करती है? उदाहरण के लिए, उपयोगकर्ता स्वयं चक्र के दोहराव की संख्या निर्धारित करना चाहता है।
ऐसे में क्या करें?
सब कुछ बहुत आसान है। संख्यात्मक प्रारंभ और समाप्ति मानों के बजाय, हम ऐसे किसी भी चर का उपयोग कर सकते हैं जिसकी गणना या उपयोगकर्ता द्वारा सेट की जा सकती है।

उदाहरण के लिए, हमें 1 से N तक की संख्याओं के वर्गों को प्रदर्शित करने की आवश्यकता है, जहां चर N का मान उपयोगकर्ता द्वारा कीबोर्ड से दर्ज किया जाता है।
कार्यक्रम कुछ इस तरह दिखेगा:
  <पूर्व> #शामिल <iostream> नेमस्पेस एसटीडी का उपयोग करना; मुख्य() { इंट आई, एन; // बुंदाबांदी में; पाश चर, एन - अधिकतम संख्या जिसके लिए हम वर्ग की गणना करते हैं सिने>> एन; // इनपुट एन कीबोर्ड से for (i = 1; i <= N; i++) // लूप: सभी i के लिए 1 से N तक - वेरिएबल i क्रमिक रूप से 1 से N तक मान लेगा { cout << "क्वाद्रत चिस्ला "<<मैं<<" रेवेन " <<मैं*मैं<<"\n"; // किसी संख्या के वर्ग को एक विशिष्ट प्रारूप में आउटपुट करना और एक नई पंक्ति में जाना } } लूप में प्रवेश करते समय, कथन i = 1 निष्पादित किया जाता है, और फिर चर i को प्रत्येक चरण के साथ एक (i ++) से बढ़ाया जाता है। स्थिति i <= N के सत्य होने पर लूप निष्पादित किया जाता है। लूप की बॉडी में, केवल आउटपुट स्टेटमेंट निर्दिष्ट प्रारूप के अनुसार स्क्रीन पर संख्या और उसके वर्ग को प्रिंट करता है।
वर्ग करने या अन्य निम्न घातांकों के लिए, गुणन का उपयोग करना बेहतर होता है।

प्रोग्राम को चलाएं और चर एन के विभिन्न मूल्यों के साथ इसके काम का परिणाम देखें।