मालवेअर हे अनाहूत किंवा धोकादायक प्रोग्राम आहेत जे...
शेवटचे अपडेट: 10/31/2018
नियंत्रण संरचनांचा आणखी एक प्रकार म्हणजे लूप. लूप तुम्हाला विशिष्ट परिस्थितींवर अवलंबून एक विशिष्ट क्रिया अनेक वेळा करण्याची परवानगी देतात. Java मध्ये खालील प्रकारचे लूप आहेत:
लूपसाठी
फॉर लूपची खालील औपचारिक व्याख्या आहे:
साठी ([काउंटर सुरू करा]; [अट]; [काउंटर बदला]) ( // क्रिया)
लूपसाठी मानक विचारात घ्या:
साठी (int i = 1; i< 9; i++){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }
लूप डिक्लेरेशनचा पहिला भाग - int i = 1 काउंटर i तयार करतो आणि आरंभ करतो. काउंटर int प्रकारचे असणे आवश्यक नाही. हा इतर कोणताही अंकीय प्रकार असू शकतो, उदाहरणार्थ फ्लोट. लूप कार्यान्वित होण्यापूर्वी, काउंटर मूल्य 1 असेल. या प्रकरणात, हे व्हेरिएबल घोषित करण्यासारखेच आहे.
दुसरा भाग अशी स्थिती आहे ज्या अंतर्गत लूप अंमलात आणला जाईल. या प्रकरणात, i 9 पर्यंत पोहोचेपर्यंत लूप चालेल.
आणि तिसरा भाग काउंटरला एकाने वाढवत आहे. पुन्हा, आम्हाला एकाने वाढवण्याची गरज नाही. तुम्ही कमी करू शकता: i-- .
परिणामी, i चे मूल्य 9 च्या बरोबरीचे होईपर्यंत लूप ब्लॉक 8 वेळा चालेल. आणि प्रत्येक वेळी हे मूल्य 1 ने वाढेल.
लूप घोषित करताना आम्हाला सर्व अटी नमूद करण्याची गरज नाही. उदाहरणार्थ, आपण असे लिहू शकतो:
इंट i = 1; साठी (; ;)( System.out.printf("%d चा वर्ग %d आहे \n", i, i * i);)
लूपची व्याख्या तशीच राहिली आहे, फक्त आता व्याख्येतील ब्लॉक्स रिक्त आहेत: साठी (; ;) . आता कोणतेही इनिशियलाइज्ड काउंटर व्हेरिएबल नाही, कोणतीही अट नाही, त्यामुळे लूप कायमचा चालेल - एक अनंत लूप.
किंवा तुम्ही अनेक ब्लॉक्स वगळू शकता:
इंट i = 1; साठी(;i<9;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); i++; }
हे उदाहरण पहिल्या उदाहरणाच्या समतुल्य आहे: आमच्याकडे एक काउंटर देखील आहे, परंतु ते लूपच्या बाहेर तयार केले आहे. आमच्याकडे लूप एक्झिक्युशनची स्थिती आहे. आणि आधीच फॉर ब्लॉकमध्येच काउंटरची वाढ आहे.
A फॉर लूप एकाच वेळी अनेक व्हेरिएबल्स परिभाषित आणि हाताळू शकते:
इंट n = 10; साठी(int i=0, j = n - 1; i< j; i++, j--){ System.out.println(i * j); }
लूप करा
do लूप प्रथम लूप कोड कार्यान्वित करतो आणि नंतर while स्टेटमेंटमधील स्थितीची चाचणी करतो. आणि जोपर्यंत ही स्थिती सत्य आहे तोपर्यंत चक्राची पुनरावृत्ती होते. उदाहरणार्थ:
इंट j = 7; do( System.out.println(j); j--; ) तर (j > 0);
या प्रकरणात, j बरोबर शून्य होईपर्यंत लूप कोड 7 वेळा चालेल. हे लक्षात घेणे महत्त्वाचे आहे की डू लूप हमी देतो की कृती किमान एकदाच अंमलात येईल, जरी व्हेल स्टेटमेंटमधील स्थिती सत्य नसली तरीही. तर, आम्ही लिहू शकतो:
इंट j = -1; do( System.out.println(j); j--; ) तर (j > 0);
जरी j सुरुवातीला 0 पेक्षा कमी असेल, तरीही लूप एकदाच कार्यान्वित होईल.
पळवाट असताना
while लूप ताबडतोब काही स्थितीची सत्यता तपासते आणि जर स्थिती सत्य असेल तर लूप कोड कार्यान्वित केला जातो:
इंट j = 6; तर (j > 0)( System.out.println(j); j--; )
सुरू ठेवा आणि विधाने खंडित करा
ब्रेक स्टेटमेंट तुम्हाला कोणत्याही वेळी लूपमधून बाहेर पडण्याची परवानगी देते, जरी लूपने त्याचे कार्य पूर्ण केले नाही:
उदाहरणार्थ:
< nums.length; i++){ if (nums[i] >10) ब्रेक; System.out.println(nums[i]); )
लूप ॲरे घटक 10 पेक्षा जास्त आहे की नाही हे तपासत असल्याने, आम्हाला कन्सोलवरील शेवटचे दोन घटक दिसणार नाहीत, कारण जेव्हा nums[i] 10 पेक्षा जास्त असेल (म्हणजे 12 च्या समान), तेव्हा ब्रेक स्टेटमेंट कार्य करेल. आणि लूप संपेल.
खरे आहे, आपल्याला शेवटचा घटक देखील दिसणार नाही, जो 10 पेक्षा कमी आहे. आता आपण हे सुनिश्चित करू की जर संख्या 10 पेक्षा मोठी असेल, तर लूप संपणार नाही, परंतु फक्त पुढील घटकाकडे जा. हे करण्यासाठी, आम्ही चालू ऑपरेटर वापरतो:
इंट संख्या = नवीन इंट ( 1, 2, 3, 4, 12, 9); साठी (int i = 0; i< nums.length; i++){ if (nums[i] >10) सुरू ठेवा; System.out.println(nums[i]); )
या प्रकरणात, जेव्हा लूप क्रमांक 12 पर्यंत पोहोचतो, जो चाचणी स्थिती पूर्ण करत नाही, तेव्हा प्रोग्राम फक्त हा क्रमांक वगळेल आणि ॲरेच्या पुढील घटकाकडे जाईल.
तुम्हाला एकाच प्रकारच्या अनेक डेटावर प्रक्रिया करण्याची गरज आहे का? मालिकेची गणना करणे आवश्यक आहे? तुम्हाला मॅट्रिक्स गुणाकार करण्याची आवश्यकता आहे का? हे सर्व आणि बरेच काही आपल्याला सायकल पूर्ण करण्यात मदत करेल! 🙂 सर्व संगणकीय प्रणाली मूळतः डेटा प्रक्रिया सुलभ करण्यासाठी डिझाइन केल्या होत्या. आणि लूपशिवाय मोठ्या प्रमाणात डेटावर प्रक्रिया करण्याची कल्पना करणे देखील अशक्य आहे.
सर्वसाधारणपणे, प्रोग्रामिंगमधील लूप सहसा तीन गटांमध्ये विभागले जातात. पहिला गट काउंटरसह सायकल आहे. त्यामध्ये, लूपचा मुख्य भाग काही वेळा कार्यान्वित केला जातो, सुरुवातीला प्रोग्रामरद्वारे निर्दिष्ट केला जातो. असा लूप निश्चितपणे ठराविक वेळा अंमलात आणला जाईल. दुसरा गट पूर्वअट असलेली सायकल आहे. त्यांच्यामध्ये, लूपचा मुख्य भाग काही स्थिती तपासल्यानंतरच कार्यान्वित केला जातो आणि जोपर्यंत ही स्थिती सत्य आहे तोपर्यंत ती कार्यान्वित केली जाईल. असे लूप एकदाच चालवले जाऊ शकत नाहीत (जर स्थिती सुरुवातीला चुकीची असेल). आणि चक्रांचा तिसरा गट म्हणजे पोस्ट कंडिशन असलेली सायकल. त्यांच्यामध्ये, लूपचा मुख्य भाग प्रथम कार्यान्वित केला जातो, नंतर स्थिती तपासली जाते. हा लूप किमान एकदा कार्यान्वित केला जाईल.
चला काउंटरसह लूपसह प्रारंभ करूया. Java मध्ये, हे लूपसाठी आहे; सर्वसाधारणपणे, ते खालीलप्रमाणे लिहिले जाऊ शकते:
साठी (प्रारंभ स्थिती; शेवटची स्थिती; बदल) ( लूप बॉडी; )
अशा प्रकारे, जर आपल्याला काही क्रिया 10 वेळा करायच्या असतील तर आपण खालील लिहावे:
साठी (int i = 0; i<10; i++) { System.out.println(i); }
असा प्रोग्राम अनुक्रमे शून्य ते नऊ पर्यंत संख्या प्रदर्शित करेल. थोडे अधिक तपशीलवार, आम्ही फक्त एक नवीन व्हेरिएबल i तयार करतो आणि त्यास प्रारंभिक मूल्य 0 (int i = 0;) नियुक्त करतो. मग आम्ही निर्दिष्ट करतो की i पर्यंत लूप कार्यान्वित केला पाहिजे< 10 и указываем каким образом должно изменяться i после каждой итерации цикла (i++).
ज्यांनी पास्कलमध्ये प्रोग्राम केले आहे त्यांना या संधीचा आनंद होईल:
इंट k = 15; साठी (float i = 0; i या उदाहरणात, i व्हेरिएबलचे मूल्य प्रत्येक पुनरावृत्तीसह 1.5 ने वाढेल. आपण तपासू शकता :). पुढील सायकल ओळीत - असताना. हे पूर्वस्थिती असलेले लूप आहे आणि सर्वसाधारणपणे ते असे लिहिले जाऊ शकते: असताना (तार्किक अभिव्यक्ती) ( क्रिया ) ठीक आहे, जर आपण कार्यरत उदाहरण घेतले तर ते असे दिसेल: असताना (ए<10)
{
System.Out.Print(a);
a++;
}
त्यामुळे, हे स्पष्ट आहे की हे लूप वापरण्यात अर्थ आहे जर तुम्हाला ध्येय साध्य करण्यासाठी किती पुनरावृत्ती आवश्यक आहेत हे माहित नसेल, परंतु तुमचे ध्येय कोणत्या स्थितीत साध्य केले जाईल हे तुम्हाला माहीत आहे. असे बांधकाम एकदाच अंमलात आणले जाऊ शकत नाही (अखेर, ही पूर्व शर्त असलेली पळवाट आहे)! लूपमधील क्रिया किती वेळा अंमलात आणल्या जातात हे व्हेरिएबलमध्ये सुरुवातीला असलेल्या मूल्यावर अवलंबून असते a. आणि चक्रांचा तिसरा प्रकार म्हणजे पोस्ट कंडिशन असलेली सायकल. त्याच्याशी खूप साम्य आहे करताना... कराफक्त मध्ये असल्यास करताना... करालूपचा मुख्य भाग कार्यान्वित करण्यापूर्वी स्थिती तपासली जाते, येथे लूपचा मुख्य भाग कार्यान्वित झाल्यानंतर स्थिती तपासली जाते. याचा अर्थ असा की कंडिशन तपासण्यापूर्वी किमान एकदा लूप कार्यान्वित केला जाईल. Java while Do लूप हे एक विधान आहे जे तुम्हाला कोडचा एकच भाग अनेक वेळा चालवण्याची परवानगी देते. जेव्हा परिस्थिती पूर्ण होते तेव्हा क्रियांची पुनरावृत्ती करण्यासाठी या लूपचा वापर केला जाऊ शकतो. जावा भाषेत व्हेल लूप सर्वात सोपा आहे. यात थोडा वेळ की, लूप कंडिशन आणि लूप बॉडी असते: असताना (अट) ( // लूप बॉडी) लूप बॉडीच्या प्रत्येक स्वतंत्र रनला पुनरावृत्ती मानली जाते. प्रत्येक पुनरावृत्तीपूर्वी, लूपच्या परिस्थितीचे मूल्यांकन केले जाते. जर लूप स्थितीचे मूल्यमापन खरे असेल तरच त्याचे मुख्य भाग कार्यान्वित केले जाते. लूपची पुनरावृत्ती काहीतरी बदलते आणि एका विशिष्ट टप्प्यावर स्थिती मूल्यमापन चुकीचे परत येते, ज्या वेळी लूप संपतो. एक लूप ज्याची स्थिती कधीही खोटी परत येत नाही अनंत वेळा अंमलात आणली जाते. अशा चक्रांना अंतहीन म्हणतात. उदाहरण int num = 0; तर (संख्या< 10) {
System.out.println(num);
num++;
} हे उदाहरण 0 ते 9 अंक मुद्रित करते. चला स्टेप बाय स्टेप कोड पाहू. प्रथम आपण 0 च्या व्हॅल्यूसह num व्हेरिएबल सुरू करतो. हे लूप काउंटर असेल. जेव्हा प्रोग्राम while वर पोहोचतो, तेव्हा लूपच्या परिस्थितीचे मूल्यमापन केले जाते. आमच्या बाबतीत 0< 10
возвращает значение true
и исполняется тело цикла. Внутри цикла выводится переменная num
, а затем увеличивается на 1
. На этом завершается первая итерация. पहिल्या "रन" नंतर, Java while लूप स्थितीचे दुसऱ्यांदा मूल्यमापन केले जाते. १< 10
по-прежнему возвращает true
, после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз. जेव्हा संख्याचे मूल्य 9 असेल तेव्हा अंतिम पुनरावृत्ती सुरू होते. लूप काउंटर शेवटच्या वेळी प्रदर्शित केले जाते आणि मूल्य 10 पर्यंत वाढवले जाते. यावेळी, एक नवीन पुनरावृत्ती सुरू केली जाऊ शकत नाही कारण लूप स्थिती असत्य वर मूल्यांकन करते. 10 असल्याने 10 पेक्षा कमी नाही. अशा प्रकारे, जोपर्यंत लूपची स्थिती पूर्ण होते तोपर्यंत लूप चालते. या ज्ञानासह सशस्त्र, आपण अधिक जटिल आणि कार्यात्मक लूप तयार करू शकता. चला ॲरेद्वारे पुनरावृत्ती करूया: स्ट्रिंग नावे = ("डॉक", "डोपी", "बॅशफुल", "ग्रंपी", "शिंक", "झोप", "आनंदी"); int index = 0; तर (अनुक्रमणिका< names.length) {
System.out.println(names);
index++;
} या उदाहरणाची संकल्पना मागील प्रमाणेच आहे. आम्ही लूप काउंटर सुरू करतो आणि सर्व घटक मुद्रित होईपर्यंत ॲरेद्वारे पुनरावृत्ती करतो. परिणामी, ॲरेजवर पुनरावृत्ती करणे ही एक सामान्य बाब आहे आणि यासाठी जावाची रचना अधिक चांगली आहे: फॉर लूप. Java while do लूप हे while सारखेच आहे, परंतु त्यात लक्षणीय फरक आहे: while च्या विपरीत, प्रत्येक पुनरावृत्तीच्या शेवटी स्थिती तपासली जाते. याचा अर्थ असा की do-while लूप नेहमी किमान एकदा कार्यान्वित केला जातो: do ( // loop body ) तर (स्थिती); उदाहरण do-while प्रथम लूपचे मुख्य भाग कार्यान्वित करते आणि नंतर त्याच्या परिस्थितीचे मूल्यांकन करते. प्राप्त परिणामावर अवलंबून, लूप थांबते किंवा पुढील पुनरावृत्ती सुरू होते. चला एक साधा खेळ पाहूया "नावाचा अंदाज लावा": स्कॅनर स्कॅनर = नवीन स्कॅनर(System.in); स्ट्रिंग अंदाज; do ( System.out.print("नावाचा अंदाज लावा:"); अंदाज = scanner.nextLine(); ) तर (!"Daffy Duck".equals(guess)); System.out.println("अभिनंदन! तुम्ही माझ्या नावाचा अंदाज लावला!"); असे असताना Java उदाहरण system.ini वरून इनपुट पार्स करण्यासाठी स्कॅनर वापरते. हे मानक इनपुट चॅनेल आहे जे बहुतेक प्रकरणांमध्ये कीबोर्डशी संवाद साधते. सोप्या भाषेत सांगायचे तर, खेळाडूने प्रविष्ट केलेला मजकूर आम्ही फक्त वाचतो. गेममध्ये, तुम्ही वापरकर्त्याला एकदा तरी विचारले पाहिजे आणि जोपर्यंत खेळाडू योग्य उत्तरे देत नाही तोपर्यंत हे करा. डू-व्हाइल लूप अशा केसेससाठी आदर्श आहे. लूपच्या मुख्य भागामध्ये, आम्हाला वापरकर्ता मूल्य मिळते आणि नंतर उत्तराची शुद्धता तपासा. वापरकर्ता इनपुट मूल्य डॅफी डकच्या बरोबरीचे होईपर्यंत लूप चालवा. योग्य उत्तर मिळाल्यास, लूप थांबतो आणि आम्ही खेळाडूला त्याच्या विजयाबद्दल अभिनंदन करतो. हे प्रकाशन लेखाचे भाषांतर आहे “ जावाचे व्हाईल आणि डू-व्हाइल लूप पाच मिनिटांत", अनुकूल प्रकल्प संघाने तयार केले जावा, जवळजवळ कोणत्याही प्रोग्रामिंग भाषेप्रमाणे, कोडच्या एका विशिष्ट भागाची वारंवार पुनरावृत्ती होते किंवा लूप होतात याची खात्री करण्यासाठी साधने आहेत, जसे त्यांना सामान्यतः म्हणतात. जावा मधील लूप हे फॉर आणि व्हेल सारख्या विधानांद्वारे तसेच त्यांच्या भिन्नतेद्वारे दर्शविले जातात. सामान्यतः, लूपचा वापर एक-आयामी आणि बहुआयामी ॲरे आणि पुनरावृत्तीयोग्य डेटा स्ट्रक्चर्स (संग्रहांसह) पार करण्यासाठी काही घटक शोधण्यासाठी आणि त्यावर कार्य करण्यासाठी केला जातो. तथापि, Java लूप सारखे साधन वापरण्याचा हा एकमेव मार्ग नाही. वापराची उदाहरणे त्यांचे पुनरावलोकन केल्यानुसार प्रदान केली जातील. Java मधील मूलभूत लूप ऑपरेटर आहे. सत्याच्या तार्किक मूल्याची पूर्तता केल्यानंतर कंसात बंद केलेल्या अभिव्यक्तीची स्थिती होईपर्यंत त्याच्या शरीरात बंद केलेला कोड तुकडा पुनरावृत्ती होईल. व्हेल स्टेटमेंटचे सामान्य स्वरूप खालीलप्रमाणे आहे: असताना(अट) ( // लूप बॉडी तार्किक स्थितीचे मूल्य सत्य होण्याचे बंद होताच, लूपच्या मुख्य भागामध्ये बंद केलेला कोड कार्यान्वित करणे थांबवेल आणि नियंत्रण ताबडतोब त्याचे अनुसरण करून लाइनवर हस्तांतरित केले जाईल. जर लूपच्या मुख्य भागामध्ये फक्त एक विधान असेल, तर कुरळे ब्रेसेस वगळले जाऊ शकतात, परंतु ते नेहमी उपस्थित असल्यास ते चांगले फॉर्म मानले जाते. वरील आकृती या ऑपरेटरच्या ऑपरेशनचे ब्लॉक आकृती दर्शवते. स्पष्टतेसाठी, खालील चित्रात सादर केलेले उदाहरण पाहू: घोषित व्हेरिएबल काउंटमध्ये सुरुवातीला व्हॅल्यू 1 आहे. पुढे ऑपरेटरच्या नावानंतर कंसात बंद केलेले लॉजिकल एक्सप्रेशन दिसेल. ते खरे असेल, म्हणजे. जोपर्यंत काउंट व्हेरिएबलचे मूल्य 10 पेक्षा कमी किंवा समान आहे तोपर्यंत खरे परत करा. लूपच्या मुख्य भागामध्ये, प्रत्येक पास (पुनरावृत्ती) सह, व्हेरिएबलचे मूल्य 1 ने वाढवले जाते आणि कन्सोल स्क्रीनवर प्रदर्शित केले जाते. लक्षात घ्या की जेव्हा व्हेरिएबल 11 वर पोहोचले तेव्हा लूप चालू होणे थांबले. जर काउंट व्हेरिएबलचे मूल्य सुरुवातीला 11 असेल तर लूपची स्थिती चुकीची असेल आणि प्रोग्राम त्याच्या शरीरात प्रवेश करणार नाही. हे लक्षात घेण्यासारखे आहे की जावा सिंटॅक्स तुम्हाला बॉडीशिवाय थोडा वेळ स्टेटमेंट वापरण्याची परवानगी देतो. एक उदाहरण देऊ. समजा आपल्याकडे i = 100 आणि j = 200 ही दोन व्हेरिएबल्स आहेत, त्यांच्या अंकगणितीय सरासरीची प्रोग्रामॅटिकली गणना करण्याचे काम आपल्यासमोर आहे - यासाठी आपण "पोकळ" वापरू शकतो जेव्हा: असताना(++i< --j); परिणामी, कोणत्याही दोन चलांचे मूल्य त्यांच्या मूळ मूल्यांच्या सरासरीइतके असेल. जसे आपण पाहू शकता, लूपने शरीराशिवाय उत्तम प्रकारे कार्य केले आणि सशर्त अभिव्यक्तीमध्ये सर्व आवश्यक क्रिया केल्या. मागील उदाहरणांमध्ये, जर कंडिशनल एक्स्प्रेशन सुरुवातीला चुकीचे असेल, तर प्रोग्राम एक्झिक्यूशन लूपच्या मुख्य भागाकडे दुर्लक्ष करेल आणि पुढे जाईल. तथापि, बर्याचदा परिस्थिती उद्भवतात ज्यामध्ये सशर्त अभिव्यक्तीच्या सत्याकडे दुर्लक्ष करून, लूपच्या मुख्य भागामध्ये असलेल्या कोडची अंमलबजावणी किमान एकदा आवश्यक असते. दुसऱ्या शब्दांत, असे घडते की सशर्त अभिव्यक्तीचे सत्य तपासणे सुरुवातीला नव्हे तर लूपच्या शेवटी आवश्यक आहे. डू-व्हाइल नावाच्या while लूपचा फरक ही कार्यक्षमता प्रदान करू शकतो. त्याचे खालील फॉर्म आहे: करा ( ) असताना(स्थिती); जसे आपण पाहू शकतो, प्रथम लूपचा मुख्य भाग कार्यान्वित केला जातो, आणि त्यानंतरच स्थितीची सत्यता तपासली जाते - आणि प्रत्येक पुनरावृत्तीवर. वरील कोड नेहमीप्रमाणेच कार्य करेल. तथापि, जर आपण संख्या 11 वर सेट केली, तर विधान अभिव्यक्तीच्या सत्यतेची चाचणी घेण्यापूर्वी लूपचा मुख्य भाग एकदाच कार्यान्वित केला जाईल. Java मध्ये एक सार्वत्रिक आणि कार्यक्षम भाषा स्वरूपाचे प्रतिनिधित्व करते. Java SDK च्या पाचव्या आवृत्तीपूर्वी, ऑपरेटरसाठी फक्त एक पारंपारिक प्रकार होता आणि त्यानंतर प्रत्येकासाठी एक नवीन दिसला. या विभागात आपण ऑपरेटरचे पारंपारिक स्वरूप पाहू. Java साठी लूप असे दिसते: लूप बॉडीमधील कोडमध्ये नियंत्रण हस्तांतरित करण्यापूर्वी, व्हेरिएबल i, जो काउंटर म्हणून कार्य करतो, प्रथम आरंभ केला जातो. पुढे, एक सशर्त अभिव्यक्ती तपासली जाते जी विशिष्ट मूल्याशी काउंटरची तुलना करते आणि जर ते सत्य परत आले, तर लूपचा मुख्य भाग कार्यान्वित केला जातो. नंतर काउंटर व्हॅल्यू पूर्वनिर्धारित पायरीद्वारे बदलली जाते आणि कंडिशनल एक्सप्रेशन पुन्हा तपासले जाते आणि कंडिशन खोटे होईपर्यंत असेच चालू राहते. खालील फ्लोचार्ट सायकलचे सर्व टप्पे स्पष्ट करतो. अधिक चांगल्या प्रकारे समजून घेण्यासाठी, जावा फॉर लूप कसे कार्य करते याचे एक उदाहरण येथे आहे: आपण पाहतो की loopVal व्हेरिएबल काउंटर म्हणून वापरले जाते. लूपच्या प्रत्येक पुनरावृत्तीनंतर, त्याचे मूल्य 1 ने वाढेल, आणि ते 11 पर्यंत पोहोचेपर्यंत हे चालू राहील. लक्षात ठेवा की कंट्रोल व्हेरिएबल स्टेटमेंटसाठी a च्या बाहेर घोषित केले जाऊ शकते, परंतु जर तुमचा या व्हेरिएबल व्यतिरिक्त कोठेही वापरण्याचा हेतू नसेल तर लूपमध्ये, ते थेट स्टेटमेंटमध्ये घोषित करण्याची शिफारस केली जाते. लक्षात ठेवा की स्टेटमेंटमध्ये घोषित केलेल्या व्हेरिएबलला त्याच लूपमध्ये स्कोप आहे. अशी परिस्थिती असते जेव्हा तुम्हाला अनेक लूप कंट्रोल व्हेरिएबल्स घोषित करण्याची आवश्यकता असते. Java साठी, एक लूप तुम्हाला स्वल्पविरामाने विभक्त केलेले दोन किंवा अधिक व्हेरिएबल्स निर्दिष्ट करण्यास अनुमती देते आणि हे त्यांच्या आरंभिकरण आणि पुनरावृत्ती दरम्यान दोन्ही करते. असा ऑपरेटर यासारखा दिसेल: साठी(int i = 1, int j = 10; i< j; ++i, --j) {} प्रत्येक पुनरावृत्तीसह, व्हेरिएबल i चे मूल्य 1 ने वाढेल, आणि व्हेरिएबल j चे मूल्य 1 ने कमी होईल. जोपर्यंत i j पेक्षा मोठे किंवा समान होत नाही तोपर्यंत पुनरावृत्ती केली जाईल. फॉर लूप हे बऱ्यापैकी लवचिक डिझाइन आहे कारण त्याचे तीनही भाग (प्रारंभ, स्थिती आणि वाढ/घट) इतर कारणांसाठी वापरले जाऊ शकतात. उदाहरणार्थ, कंट्रोल व्हेरिएबलसह कंडिशनल एक्सप्रेशनऐवजी, तुम्ही कोणतेही लॉजिकल व्हेरिएबल बदलू शकता. बुलियन निर्गमन = खोटे; साठी (int i = 0; !बाहेर पडा; ++i) ( वरील उदाहरणात, लूपचे ऑपरेशन कंट्रोल व्हेरिएबल i पासून पूर्णपणे कसे स्वतंत्र आहे हे आपण पाहू शकतो आणि पुनरावृत्तीची संख्या केवळ एक्झिट व्हेरिएबल ज्या क्षणी सत्य होते त्यावर अवलंबून असते. शिवाय, कंट्रोल व्हेरिएबल लूपमधून पूर्णपणे काढून टाकले जाऊ शकते आणि यामुळे त्याच्या ऑपरेशनवर कोणत्याही प्रकारे परिणाम होणार नाही: for(; !exit;) (). हा प्रोग्राम करण्याचा सर्वात हुशार मार्ग नसला तरी, तो कधीकधी उपयुक्त ठरू शकतो. मुख्य गोष्ट अशी परिस्थिती प्रदान करणे आहे ज्यामध्ये व्हेरिएबल लूपमधून बाहेर पडण्यासाठी आवश्यक मूल्य घेईल, जेणेकरून ते अनंतामध्ये बदलू नये. Java साठी, लूप अशा प्रकारे घोषित केला जाऊ शकतो: for(; ;) (). विशेष व्यत्यय परिस्थितीसह अनंत लूपचे हे एक सामान्य उदाहरण आहे. या प्रकारच्या चक्रात व्यत्यय कसा आणायचा याबद्दल आम्ही थोड्या वेळाने बोलू. Java foreach लूप नेहमी ॲरे किंवा इतर कोणत्याही घटकांद्वारे क्रमशः पुनरावृत्ती करण्यासाठी आणि त्यावर विशिष्ट पुनरावृत्ती ऑपरेशन्स करण्यासाठी वापरला जातो. फॉर स्टेटमेंटच्या या स्वरूपाचे उदाहरण खाली दर्शविले आहे: नाव पुनरावृत्ती व्हेरिएबल म्हणून घोषित केले जाते, आणि पूर्वी घोषित केलेल्या स्ट्रिंग नावांचे ॲरे ऑपरेटरचे दुसरे वितर्क म्हणून कार्य करते. व्हेरिएबल नाव ॲरेच्या प्रत्येक घटकाची मूल्ये घेतील जोपर्यंत त्याचे सर्व घटक पुनर्प्राप्त होत नाहीत. हे लक्षात घ्यावे की व्हेरिएबलचा प्रकार ॲरेमध्ये साठवलेल्या घटकांच्या प्रकाराशी सुसंगत असणे आवश्यक आहे. तसेच, नाव व्हेरिएबल केवळ वाचनीय आहे आणि ते बदलण्याचा प्रयत्न केल्याने ॲरेमधील घटक बदलणार नाहीत. तीन लूप इंटरप्ट स्टेटमेंट आहेत: ब्रेक, रिटर्न आणि कंटिन्यू. पहिले दोन लूपमध्ये पूर्णपणे व्यत्यय आणण्यास सक्षम आहेत, तर सुरू ठेवल्याने फक्त वर्तमान पुनरावृत्तीमध्ये व्यत्यय येतो. तुम्ही तुमच्या कोडमध्ये Java मध्ये मुद्दाम अनंत लूप वापरत असल्यास, हे ऑपरेटर त्यात उपस्थित असणे आवश्यक आहे. ब्रेक वापरण्याचे एक साधे उदाहरण पाहू: या स्टेटमेंटसाठी 11 पुनरावृत्ती असली तरी, फक्त 8 कार्यान्वित केले जातील, कारण जेव्हा संख्या i 7 च्या बरोबरीची असेल, तेव्हा ब्रेक स्टेटमेंट असलेली स्थिती ट्रिगर केली जाईल. रिटर्न स्टेटमेंट सारख्याच प्रकारे कार्य करते, या फरकासह की ते केवळ Java लूपमधून बाहेर पडण्याची सुविधा देत नाही तर लूप ठेवलेल्या पद्धतीतून देखील. हे लक्षात घेतले पाहिजे की ब्रेक केवळ शरीरातील लूपमध्ये व्यत्यय आणतो ज्यामध्ये ते थेट स्थित आहे, म्हणजे. जर तुम्ही ते नेस्टेड लूपमध्ये वापरत असाल, तर बाह्य लूप चालणे थांबणार नाही. हे करण्यासाठी, ब्रेक स्टेटमेंट गोटोचे सभ्य स्वरूप म्हणून वापरले जाऊ शकते. या आवृत्तीमध्ये, या ऑपरेटरचा वापर लेबलसह केला जातो, जो आपल्याला केवळ लूपमधूनच नव्हे तर कोडच्या कोणत्याही ब्लॉकमधून देखील एक्झिट आयोजित करण्यास अनुमती देतो. लेबल हे योग्यरित्या नाव दिलेले आयडेंटिफायर असून त्यानंतर कोलन असते. चिन्हांकित केलेल्या कोड ब्लॉकच्या सुरुवातीला लेबल घोषित केले जाते. चिन्हांकित ब्लॉकच्या अंमलबजावणीमध्ये व्यत्यय आणण्यासाठी, आपण योग्य ठिकाणी घोषित करणे आवश्यक आहे: लेबल_नाम ब्रेक करा. खालील चित्रातील उदाहरण विचारात घ्या: कोड अनुक्रमे एक, दोन आणि तीन या लेबल नावांसह तीन ब्लॉक घोषित करतो. दोन लेबल केलेले ब्रेक स्टेटमेंट सर्व तीन ब्लॉक्समध्ये नेस्टेड केले आहे, परंतु जेव्हा ते सुरू होते, तेव्हा प्रोग्राम ब्लॉक तीन आणि दोनमधून बाहेर पडेल आणि ब्लॉक एकमध्ये अंमलबजावणी सुरू ठेवेल. त्या. कन्सोलमध्ये आपल्याला दोन संदेश दिसतील: तीन आणि एक. आम्ही Java मधील लूपची संकल्पना शिकलो, मुख्य असताना आणि विधानांसाठी आणि अनुक्रमे त्यांचे do-while आणि प्रत्येक फॉर्मसाठी. अधिक चांगल्या प्रकारे समजून घेण्यासाठी, आम्ही या ऑपरेटर्सचा वापर करून विविध फॉर्ममध्ये व्यायाम करण्याची शिफारस करतो, तसेच त्यांना व्यत्यय आणण्यासाठी आणि एका ब्लॉकमधून दुसऱ्या ब्लॉकमध्ये जाण्याचे विविध मार्ग. जवळजवळ कोणत्याही प्रोग्रामिंग भाषेप्रमाणे, Java मध्ये कोडच्या विशिष्ट भागाची वारंवार पुनरावृत्ती करण्यासाठी डिझाइन केलेली साधने आहेत. अशा साधनांना सहसा सायकल म्हणतात. Java मध्ये, लूप हे व्हेअर आणि फॉर आणि त्यांच्या फरकांसारख्या विधानांद्वारे दर्शविले जातात. लूपचा वापर सामान्यत: एक- आणि बहु-आयामी ॲरे आणि डेटा स्ट्रक्चर्समधून विशिष्ट घटक शोधण्यासाठी आणि त्यावर पुढील ऑपरेशन्स करण्यासाठी केला जातो. परंतु Java लूप सारखे साधन वापरण्याचा हा एकमेव मार्ग आहे. आम्ही त्यांचे पुनरावलोकन करत असताना वापराची उदाहरणे दिली जातील. Java while loop: वर्णन आणि उदाहरणे Java मधील मूलभूत लूप ऑपरेटर आहे. त्याच्या मुख्य भागामध्ये बंद केलेला कोड तुकडा कंसात बंद केलेल्या अभिव्यक्तीची स्थिती पूर्ण होईपर्यंत पुनरावृत्ती केली जाईल. सर्वसाधारणपणे while ऑपरेटरचे खालील स्वरूप असते: while (condition)(//loop body). एकदा बूलियन कंडिशन यापुढे सत्य नसल्यास, लूप बॉडीमध्ये बंद केलेला कोड यापुढे कार्यान्वित केला जाणार नाही. त्यानंतर लगेच येणाऱ्या लाईनवर नियंत्रण हस्तांतरित केले जाईल. जर लूपच्या मुख्य भागामध्ये फक्त एक विधान असेल, तर तुम्ही कुरळे ब्रेसेस वगळू शकता. तथापि, प्रोग्रामरमध्ये ते नेहमी सेट करणे चांगले मानले जाते. चला एक उदाहरण पाहू: डेमो करताना सार्वजनिक वर्ग ( System.out.println ("1 ते 10 पर्यंत अंक मुद्रित करणे"); तर (गणना<=10) { System.out.println(count); सुरुवातीला घोषित व्हेरिएबल काउंटचे मूल्य 1 आहे. पुढे आपल्याला तार्किक अभिव्यक्ती दिसते, जी ऑपरेटरच्या नावानंतर कंसात बंद केलेली आहे. जर व्हॅल्यू सत्य असेल, तर लूप सत्यात परत येईल जोपर्यंत काउंट व्हेरिएबलचे मूल्य 10 च्या बरोबरीचे किंवा त्यापेक्षा कमी होत नाही. प्रत्येक पास किंवा पुनरावृत्तीसह, व्हेरिएबलचे मूल्य 1 ने वाढवले जाईल आणि कन्सोल स्क्रीनवर प्रिंट केले जाईल. व्हेरिएबलचे मूल्य 11 वर पोहोचल्यावर, लूप संपुष्टात आला. जर काउंट व्हेरिएबलचे मूल्य सुरुवातीला 11 च्या समान असेल, तर लूप कंडिशन असत्य असेल. कार्यक्रम शरीरातही शिरणार नव्हता. हे लक्षात घ्यावे की जावा सिंटॅक्स तुम्हाला बॉडीशिवाय while स्टेटमेंट वापरण्याची परवानगी देतो. खालील उदाहरणाचा विचार करा. समजा तुमच्याकडे दोन व्हेरिएबल्स आहेत: i=100 आणि j=200. आम्हाला त्यांच्या अंकगणित सरासरीची प्रोग्रामॅटिक पद्धतीने गणना करण्याचे कार्य सामोरे जात आहे, या उद्देशासाठी आम्ही लूप करताना "पोकळ" वापरू शकतो: असताना(++i<- — j); या ऑपरेशनचा परिणाम म्हणून, या दोन चलांपैकी कोणत्याही व्हेरिएबल्सचे मूल्य त्यांच्या सुरुवातीच्या मूल्यांच्या सरासरीइतके असेल. जसे आपण या उदाहरणात पाहू शकता, लूपने शरीराशिवाय चांगले काम केले आणि सशर्त अभिव्यक्तीमध्ये सर्व आवश्यक क्रिया केल्या. do-while लूप मागील उदाहरणांमध्ये, जर कंडिशन एक्सप्रेशन चुकीचे परत आले, तर प्रोग्रामने लूपच्या मुख्य भागाकडे दुर्लक्ष केले आणि पुढील अंमलबजावणी सुरू ठेवली. परंतु काहीवेळा परिस्थिती उद्भवते जेव्हा लूपच्या मुख्य भागामध्ये असलेला कोड किमान एकदा कार्यान्वित करणे आवश्यक आहे, स्थिती अभिव्यक्तीच्या सत्याकडे दुर्लक्ष करून. दुसऱ्या शब्दांत, काहीवेळा असे घडते की आपल्याला लूपच्या शेवटी ऐवजी सुरुवातीला सशर्त अभिव्यक्तीचे सत्य तपासण्याची आवश्यकता असते. व्हेल लूपचा एक फरक, कोड-नावात do-while, समान कार्यक्षमता प्रदान करू शकतो. त्याचे खालील स्वरूप आहे: do (//loop body) while (condition). जसे आपण पाहू शकता, प्रथम लूपचा मुख्य भाग येथे कार्यान्वित केला जातो आणि नंतर स्थितीची सत्यता तपासली जाते. हे प्रत्येक पुनरावृत्तीवर केले जाते. वरील कोड अंदाजे प्रमाणेच कार्य करेल. परंतु जर आपण संख्या 11 वर सेट केली, तर विधान अभिव्यक्तीच्या सत्यतेची चाचणी घेण्यापूर्वी लूपचा मुख्य भाग एकदाच कार्यान्वित केला जाईल. उदाहरणे आणि वर्णन: साठी – Java लूप जावा भाषेतील फॉर लूप हा एक सार्वत्रिक आणि कार्यक्षम भाषा प्रकार आहे. JavaSDK च्या आवृत्ती 5 पर्यंत, फॉर स्टेटमेंटचा एकच पारंपारिक प्रकार होता. त्यानंतर, एक नवीन दिसू लागले - पूर्वाश्रमीची. हा विभाग ऑपरेटरच्या पारंपारिक स्वरूपावर लक्ष केंद्रित करेल. जावा मधील फॉर लूप असे दिसते: साठी (inti=0; i<10; i++) {//Loop statements to be executed लूपच्या शेवटी कोडमध्ये नियंत्रण हस्तांतरित करण्यापूर्वी, व्हेरिएबल i आरंभ केला जातो, जो काउंटर म्हणून कार्य करतो. पुढे, आपल्याला सशर्त अभिव्यक्ती तपासण्याची आवश्यकता आहे ज्यामध्ये काउंटरची विशिष्ट मूल्याशी तुलना केली गेली होती. जर प्रोग्राम सत्य परत आला तर, लूपचा मुख्य भाग कार्यान्वित केला जाईल. या प्रकरणात, काउंटर मूल्य पूर्वनिर्धारित चरणानुसार बदलते आणि सशर्त अभिव्यक्ती पुन्हा तपासली जाते. स्थिती खोटी होईपर्यंत हे घडते. चांगल्या प्रकारे समजून घेण्यासाठी, जावा फॉर लूप कसे कार्य करते याचे उदाहरण येथे दिले आहे. सार्वजनिक वर्ग ForLoops ( सार्वजनिक स्थिर शून्य मुख्य (स्ट्रिंग आर्ग्स) ( intend_value =11; च्या साठी )पळवाट असताना
do-while लूप
अनुमान मध्ये
Java's while true loops तुम्हाला कोडचे तुकडे अनेक वेळा पुन्हा वापरण्याची परवानगी देतात. आज आपल्याला Java while आणि do-while loops ची ओळख झाली. ते समान आहेत कारण ते परिस्थिती तपासतात आणि स्थितीचे मूल्यमापन खरे असल्यास लूपचे मुख्य भाग कार्यान्वित करतात. परंतु त्याच वेळी, त्यांच्यात महत्त्वपूर्ण फरक आहे: पुनरावृत्तीच्या आधी व्हाईल लूपची स्थिती तपासली जाते आणि प्रत्येक पुनरावृत्तीच्या शेवटी डू-व्हाइल लूपची स्थिती तपासली जाते. याचा अर्थ असा की do-while लूप नेहमी किमान एकदा कार्यान्वित केला जातो. जावा: वर्णन आणि उदाहरणे
do-while लूप
// लूप बॉडी
साठीचे वर्णन आणि उदाहरणे - Java लूप
ऑपरेटरसाठी वापरण्याची वैशिष्ट्ये
प्रत्येक शैली लूपसाठी
लूप व्यत्यय विधाने
गोटो म्हणून ब्रेक वापरणे
निष्कर्ष
