जावा फॉर लूप

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

जावा मध्ये फॉर लूप कसे लिहायचे? सर्वसाधारणपणे लूपसाठी

फॉर लूप काही विधाने ठराविक वेळा कार्यान्वित करते. उदाहरणार्थ, पन्नास वेळा "मी असे नसावे, हो-हो, हो" लिहिणे किंवा तुमच्या सर्व मित्रांना आमंत्रणे पाठवणे ही अशा प्रकारच्या लूपसाठी विशिष्ट कार्ये आहेत. फॉर लूपच्या सर्वात सामान्य आवृत्तीचे वाक्यरचना:

for ([counter initialization]; [checking conditions]; [changing of the counter])
{
    //  statements
}

आरंभिक अभिव्यक्ती एकदा अंमलात आणली जाते, त्यानंतर स्थितीचे मूल्यमापन केले जाते, जी बुलियन अभिव्यक्ती असावी.

• जेव्हा लूप सुरू होतो तेव्हा इनिशियलायझेशन कार्यान्वित होते.
• जेव्हा परिस्थितीचे मूल्यमापन असत्य ठरते, तेव्हा आमचे लूप त्याचे कार्य थांबवते.

काउंटर बदलत आहे, सामान्यतः लूपद्वारे प्रत्येक पुनरावृत्तीनंतर वाढ (किंवा घट) होते. तुम्ही तीनपैकी कोणतेही लूप एक्सप्रेशन वगळू शकता (प्रारंभ, स्थिती तपासणे, काउंटर बदलणे). लूपच्या पुढील चरणापूर्वी लूपची स्थिती तपासली जाते. कंडिशन असत्य असल्यास, प्रोग्रॅम लूपच्या बाहेर जातो आणि फॉर कन्स्ट्रक्टचे अनुसरण करून सूचना चालू ठेवतो. येथे आपल्याकडे फॉर लूपचा ब्लॉक आकृती आहे.

Java मध्ये लूप कसे वापरावे. साधे उदाहरण.

लूप उदाहरणासाठी येथे एक विशिष्ट Java आहे. चला दहा वेळा "हॅलो!" स्ट्रिंग प्रत्येक वेळी या ओळीच्या संख्येसह नवीन ओळीतून असेल. आम्हाला पुढील आउटपुट मिळाले पाहिजे:

1. नमस्कार!
2. नमस्कार!
3. नमस्कार!
4. नमस्कार!
5. नमस्कार!
6. नमस्कार!
7. नमस्कार!
8. नमस्कार!
9. नमस्कार!
10. नमस्कार!

हा आमचा जावा प्रोग्राम आहे जो या समस्येचे निराकरण करतो:

public class ForExample {
   public static void main(String[] args) {
       for (int i = 0; i < 10; i++) {
           System.out.println(i + 1 + ". Hello!");
       }
   }
}

हे कसे कार्य करते?

पायरी 1. काउंटर i = 0. लूप आपली स्थिती तपासते, i << 10, म्हणून, लूप स्टेटमेंट कार्यान्वित केले जातात. ते "1. हॅलो!" वाक्यांश मुद्रित करते. 1 ही i + 1 स्ट्रिंग आहे (कारण आम्ही शून्यातून मोजले, परंतु पहिली ओळ अजूनही पहिली आहे). काउंटर i वाढवलेला आहे. आता, i = 1. पायरी 2. काउंटर i = 1. i < 10, म्हणून आम्हाला "2. नमस्कार!" एक वाक्यांश आला आहे. आणि i + 1 = 2. … पायरी 10. काउंटर i = 9, आम्हाला "10. नमस्कार!" आला आहे. आणि i 10 पर्यंत वाढवला जातो. पायरी 11. काउंटर i = 10. i < 10 ? नाही, ते खोटे आहे. म्हणून, लूप संपला आहे.

लूप आणि फॉर लूप असताना: फरक आणि समानता

Java मध्ये indefinite loop किंवा while loop बूलियन कंडिशन खरे झाल्यास सतत कार्यान्वित केले जाते. while loop चे वाक्यरचना:

while (boolean condition)
       {
            loop statements...
       }

बर्‍याचदा तुम्हाला कोणता लूप वापरायचा आहे ते तुम्ही निवडू शकता. कधीकधी ते खूप जवळ असतात आणि आपण ते दोन्ही वापरू शकता. उदाहरणार्थ, त्याच कार्यासाठी कोड येथे आहे (अनेक ओळींसह दहा वेळा "हॅलो!" लिहिणे) while लूपसह लिहिले:

public class ForAndForEach {
   public static void main(String[] args) {
       int j = 0;  //  we use the counter this way 
       while (j < 10) {
           System.out.println(j + 1 + ". Hello!");
           j++;
       }
   }
}

तथापि, प्रोफेशनल प्रोग्रामरना व्हेईल लूप आवडत नाही आणि जेथे शक्य असेल तेथे फॉर लूप वापरण्याचा प्रयत्न करा.

जावा मधील फॉर लूपमधून कसे बाहेर पडायचे

सहसा फॉर लूप प्रवाहाप्रमाणे चालत असतो आणि जेव्हा एखादी स्थिती चुकीचे मूल्य घेते तेव्हा लूपमधून बाहेर पडण्याचा नैसर्गिक मार्ग असतो. तथापि, दोन नियंत्रण विधाने आहेत जी तुम्हाला कंडिशनचे चुकीचे मूल्य मिळण्यापूर्वी लूपमधून बाहेर पडण्याची परवानगी देतात — खंडित करा आणि सुरू ठेवा.

• ब्रेक वर्तमान लूप बॉडीमधून बाहेर पडू देते जसे की लूप कंडिशनचे मूल्यमापन असत्य केले आहे.
• स्टेटमेंट कार्यान्वित न करता कंटिन्यू लूपला पुढील पायरीवर जाण्यासाठी (काउंटरची पुनरावृत्ती) करते.

ब्रेक आणि सुरू ठेवून पुढील समस्या सोडवू. आमच्याकडे नावांची अ‍ॅरे आहे आणि आम्ही अनोळखी लोकांशिवाय या अ‍ॅरेमधील सर्वांना नमस्कार म्हणतो. म्हणून जर आम्हाला आमच्या लूप दरम्यान "अनोळखी" स्ट्रिंग भेटली तर आम्ही त्यातून बाहेर पडू (दूर जाऊन इतर कोणालाही नमस्कार करणे थांबवा).

public class ForBreakExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
//  how to break out of a for loop, java: check if we have any "Stranger" in  //  our array            
if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               break;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

आमच्या प्रोग्रामच्या अंमलबजावणीचा परिणाम आहे:

Hello,Mike
Hello,Dustin
I don't chat with strangers

पहा? आम्ही लुकास आणि विल यांना अभिवादन करण्यापूर्वी लूपमधून पळ काढला. आता सुरू ठेवूया, फक्त एखाद्या "अनोळखी" व्यक्तीकडे दुर्लक्ष करण्यासाठी पण इतर मित्रांना नमस्कार करण्यासाठी लूपमध्ये राहा.

public class ForContinueExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
           if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

परिणाम आहे:

Hello,Mike
Hello,Dustin
I don't chat with strangers
Hello,Lucas
Hello,Will

उत्कृष्ट! आम्ही सर्व मित्रांना नमस्कार केला, परंतु अनोळखी व्यक्तीशी बोललो नाही.

लूपसाठी किंवा प्रत्येकासाठी ची वर्धित आवृत्ती

for-each हा एक प्रकारचा लूप आहे जो तुम्हाला अॅरे किंवा संग्रहाच्या सर्व घटकांवर प्रक्रिया करण्याची आवश्यकता असताना वापरला जातो. वास्तविक, या चक्रात प्रत्येकासाठी-वाक्प्रचार वापरला जात नाही. वाक्यरचना खालीलप्रमाणे आहे:

for (type itVar: array)
{
    Block of operators;
}

जेथे प्रकार हा पुनरावृत्ती व्हेरिएबलचा प्रकार आहे (अॅरेच्या डेटा प्रकाराप्रमाणेच), ItVar हे त्याचे नाव आहे, अॅरे हे अॅरे आहे किंवा दुसरी डेटा रचना असू शकते, उदाहरणार्थ, अॅरेलिस्ट. जसे तुम्ही बघू शकता, तेथे कोणतेही काउंटर नाही, पुनरावृत्ती व्हेरिएबल अॅरे किंवा कलेक्शनच्या घटकांवर पुनरावृत्ती होते, आणि निर्देशांक मूल्यांवर नाही. जेव्हा असा लूप कार्यान्वित केला जातो, तेव्हा पुनरावृत्ती व्हेरिएबलला क्रमाने अॅरे किंवा संकलनाच्या प्रत्येक घटकाचे मूल्य नियुक्त केले जाते, त्यानंतर विधानांचा निर्दिष्ट ब्लॉक (किंवा ऑपरेटर) कार्यान्वित केला जातो. लक्ष द्या: प्रत्येकासाठी लूप अॅरे आणि java.lang.Iterable इंटरफेस लागू करणार्‍या कोणत्याही वर्गांना लागू केले जाऊ शकते. अनोळखी व्यक्तींकडे दुर्लक्ष करून ("अनोळखी") ग्रीटिंग्ज मित्रांसोबत समान समस्या सोडवूया, परंतु यावेळी प्रत्येकासाठी लूप वापरा.

public class ForEachExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
	//  for each loop, Java code
       for (String name : names) {
           if (name.equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("hello, " + name);
       }
   }
}

तुम्ही जे शिकलात ते बळकट करण्यासाठी, आम्ही तुम्हाला आमच्या Java कोर्समधील व्हिडिओ धडा पाहण्याचा सल्ला देतो