जावा में लूप के लिए कैसे लिखें

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

जावा में लूप के लिए

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

लूप सिंटैक्स के लिए प्रोग्रामिंग भाषाओं में समान है। इसलिए, यदि आपने किसी अन्य प्रोग्रामिंग भाषा में लूप के लिए बनाया है, तो लूप के लिए एक जावा परिचित होगा। हालाँकि, यदि आप जावा से बिल्कुल भी परिचित नहीं हैं, तो यह सलाह दी जाती है कि आप लूप के लिए उन्नत विषयों को सीखने से पहले एक शुरुआती ट्यूटोरियल पढ़ें।

 for([statement1]; [condition]; [statement2]){
 //code to execute each loop
 }

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

 public class Main{
 public static void main(String[] args) {
 for(int i = 1; i < 4; i++){
 System.out.print(i);
 }
 }
 }
 //Output: 123

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

संबंधित: कोर जावा कॉन्सेप्ट आपको शुरू होने पर सीखना चाहिए

लूप के लिए नेस्टेड

एक बार जब आप लूप के लिए हैंग हो जाते हैं, तो आपको लूप के लिए नेस्टेड बनाने की कोशिश करनी चाहिए। यह तब होता है जब आपके पास लूप के लिए दूसरे के अंदर लूप होता है। यह एक उन्नत तकनीक है क्योंकि यह समझना मुश्किल हो सकता है कि दोनों लूप कैसे बातचीत करेंगे। लूप्स के लिए नेस्टेड कैसे काम करता है, यह कल्पना करने का एक अच्छा तरीका है कि लूप के लिए नेस्टेड के साथ निम्न पैटर्न बनाया जाए।

 *
 **
 ***

इसे बनाने के लिए, हमें यह नियंत्रित करने के लिए एक लूप की आवश्यकता होगी कि प्रत्येक रेखा पर कितने तारे मुद्रित हैं, और दूसरी लूप को नियंत्रित करने के लिए कि कितनी रेखाएँ बनानी हैं। जब आप लूप के लिए नेस्टेड होते हैं तो यह निर्धारित करना मुश्किल हो सकता है कि कौन सा लूप इनर लूप है। इस मामले में, तारों को प्रिंट करने वाला लूप आंतरिक लूप है। हमें हर बार नई लाइन बनाने के लिए लूप की आवश्यकता होती है।

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

 for(int lineCounter = 1; lineCounter < 4; lineCounter++){
 for(int starCounter = 1; starCounter <= lineCounter; starCounter++){
 System.out.print("*");
 }
 System.out.print("n");
 }

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

अनंत लूप

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

एक अनंत लूप बनाने के लिए, आप निम्नलिखित सिंटैक्स का उपयोग कर सकते हैं:

 for(;;){
 //code that never stops looping
 }

संबंधित: वेबसाइट और एप्लिकेशन जो जावा प्रोग्रामिंग सीखने में मदद कर सकते हैं

एक ऐरे के साथ फॉर लूप का

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

 System.out.print([array]);

यह कमांड ऐरे के बारे में जानकारी प्रिंट करेगा, एरे की सामग्री के बारे में नहीं। सरणी की सामग्री को प्रिंट करने के लिए, आपको सरणी में प्रत्येक व्यक्तिगत तत्व को प्रिंट करना होगा। यह कोड के लिए समय लेने वाला होगा, लेकिन आप प्रत्येक तत्व के माध्यम से जाने के लिए लूप बना सकते हैं।

 String[] words = {"Hello", " ", "World", "!"};

 for(int i = 0; i < words.length; i ++){
 System.out.print(words[i]);
 }

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

आउटपुट:

 Hello World!

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

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

 for([dataType] [arrayElement] : [array]){
 //code to be executed
 }

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

 String[] words = {"Hello", " ", "World", "!"};

 for(String word : words){
 System.out.print(word);
 }

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

जब एक लूप के लिए उपयोग करने के लिए

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