लूप (ब्रेक आणि रिटर्न, सुरू ठेवा, लेबल्स)

"हाय, अमिगो!"

"आज मी तुम्हाला काही गोष्टींबद्दल सांगेन ज्या लूपसह काम करताना सोयीस्कर असतात."

"पहिला कीवर्ड ब्रेक आहे. जर तुम्ही ही कमांड लूपच्या बॉडीमध्ये वापरत असाल, तर कमांड कार्यान्वित झाल्यावर लूप ताबडतोब संपुष्टात येईल. येथे एक उदाहरण आहे:"

for (int i = 0; i < 10; i++)
{
System.out.println(i);
if (i > 5)
break;
}

"ब्रेक फक्त लूपमध्ये वापरला जाऊ शकतो?"

"होय. ब्रेक स्टेटमेंट फक्त लूपमध्ये वापरले जाऊ शकते. जेव्हा ब्रेक स्टेटमेंट कार्यान्वित केले जाते, तेव्हा लूप ताबडतोब बंद होते."

"ठीक आहे. समजले."

"छान. आता दुसरी गोष्ट जी मला शेअर करायची आहे ती म्हणजे पुढे चालू ठेवा. तो फक्त लूपमध्ये वापरला जाऊ शकतो. जेव्हा ही आज्ञा कार्यान्वित केली जाते, तेव्हा लूपची नवीन पुनरावृत्ती लगेच सुरू होते. दुसऱ्या शब्दांत, कोणताही शिल्लक असलेला कोड लूपचा मुख्य भाग फक्त वगळला आहे."

"हे एक उदाहरण आहे:"

for (int i = 0; i < 10; i++)
{
if (i % 2 == 0)
continue;
System.out.println(i);
}

"म्हणून, एकदा प्रोग्राम लूपमध्ये कंटिन्यू कमांडवर पोहोचला की, तो लूपमधील कोड कार्यान्वित करणे थांबवतो?"

"नाही. पहा, जेव्हा आपण समान कोड अनेक वेळा कार्यान्वित करतो तेव्हा आपल्याकडे एक लूप असतो. वरील उदाहरणात, आपल्याकडे 0 ते 9 पर्यंत लूप आहे, म्हणजे लूपचा मुख्य भाग 10 वेळा कार्यान्वित होईल. बरोबर?"

"हो."

"लूपच्या मुख्य भागातून एका पासला पुनरावृत्ती म्हणतात. आमच्या लूपमध्ये 10 पुनरावृत्ती असतात- लूपचा मुख्य भाग दहा वेळा कार्यान्वित केला जाईल."

"हो, ते स्पष्ट आहे."

" continue कमांड वर्तमान पुनरावृत्ती वेळेआधीच संपुष्टात आणते, म्हणजे लूपमधील कोणताही उर्वरित कोड वगळला जातो आणि नवीन पुनरावृत्ती सुरू होते."

"हे दुसरे उदाहरण आहे:"

ArrayList list = new ArrayList();
for (Object o: list)
{
if (o == null) continue;
System.out.println(o.toString());
}

"या उदाहरणात, आम्ही सूचीतील सर्व ऑब्जेक्ट्सचे स्ट्रिंग रिप्रेझेंटेशन प्रदर्शित करतो. परंतु आम्ही शून्य असलेल्या कोणत्याही ऑब्जेक्ट्स वगळतो."

"ठीक आहे, समजले. हे किती सोयीचे आहे ते मी पाहू शकतो."

"हो. मला तुम्हाला लेबलांबद्दल देखील सांगायचे आहे. ते जावामध्ये क्वचितच वापरले जातात, कारण ते प्रोग्रामच्या लॉजिकच्या सौंदर्याचे उल्लंघन करतात. परंतु तुम्हाला ते कोडमध्ये कधीतरी आढळू शकतात. म्हणून मी तुम्हाला त्याबद्दल सांगू इच्छितो. खेळाच्या मैदानावर तुम्ही त्यांच्याबद्दल ऐकले असेल त्यापेक्षा त्यांना."

"एकेकाळी कोडमधील कोणत्याही ओळीवरून कोणत्याही ओळीवर जाण्याची परवानगी होती. आम्ही हे लेबल आणि गोटो स्टेटमेंट वापरून केले. ते कसे दिसते ते येथे आहे:"

System.out.println("Make cookies,");
label: System.out.println("not");
System.out.println("war");
goto label;

"या उदाहरणात, goto लेबल कमांड कार्यान्वित झाल्यानंतर, प्रोग्राम चिन्हांकित लेबलवर जातो .

"नंतर, सर्वांनी शहाणपणा केला आणि गोटो विधान न वापरण्याचा निर्णय घेतला. जावा गोटोला समर्थन देत नाही, परंतु गोटो हा आरक्षित शब्द आहे. काही मोठी गोष्ट नाही..."

"मग, जावामध्ये गोटो नाही आणि लेबले नाहीत?"

"कोणतेही गोटो विधान नाही, परंतु लेबले आहेत!"

"असं कसं होऊ शकतं?"

"जावामध्ये, कंटीन्यु आणि ब्रेक कमांडसह लेबल्स वापरता येतात. जेव्हा तुमच्याकडे अनेक नेस्टेड लूप असतात तेव्हा ते वापरले जातात."

"उदाहरणार्थ, समजा तुमच्याकडे 5 नेस्टेड लूप आहेत आणि जेव्हा काही परिस्थिती पूर्ण होते तेव्हा तुम्हाला त्यापैकी तीन मधून बाहेर पडायचे आहे, परंतु सर्व नाही. हे करण्यासाठी लेबल हा एक सुंदर मार्ग आहे:"

label1: for (int i = 0; i < 10; i++)
 label2: for (int j = 0; j < 10; j++)
  label3: for (int k =0; k < 10; k++)
   if (i == j && j == k)
    break label2;

"या उदाहरणात, जेव्हा ब्रेक स्टेटमेंट कार्यान्वित केले जाते, तेव्हा आपण k व्हेरिएबल असलेल्या लूपमधून बाहेर पडत नाही, तर लेबल 2 असलेल्या लूपमधून बाहेर पडतो - म्हणजे आपण k आणि j सह दोन लूपमधून लगेच बाहेर पडतो."

"किती वेळा वापरले जाते?"

"प्रामाणिकपणे सांगायचे तर, अनेकदा नाही, पण तुम्हाला कधीच कळत नाही. कदाचित तुम्हाला ते कधीतरी दिसेल. ही वाक्यरचना मूलभूत तत्त्वे आहेत- तुम्हाला हे सर्व माहित असणे आवश्यक आहे!"

"ठीक आहे. धन्यवाद, बिलाबो."