आमचे पहिले कार्यक्रम हे एकामागून एक कार्यान्वित होणाऱ्या सूचनांचा क्रम होता. काटे नाहीत. यामध्ये हॅलोवर्ल्डचा समावेश आहे, जे ग्रीटिंग दाखवते. त्यात अंकगणितीय गणनांचा समावेश आहे. आमच्या पहिल्या कार्यक्रमांनंतर, आम्ही शाखा कशी करायची ते शिकलो, म्हणजे विशिष्ट परिस्थितीनुसार प्रोग्रामला वेगवेगळ्या क्रिया कशा करायच्या. सेंट्रल हीटिंग आणि एअर कंडिशनिंग सिस्टम नियंत्रित करण्यासाठी येथे कोड आहे:

if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort)
    heaterOn();
पुढचे पाऊल टाका. दैनंदिन जीवनात, आम्ही अनेकदा एकसमान पुनरावृत्ती क्रिया करतो, उदाहरणार्थ, पाईसाठी सफरचंद सोलणे. या आकर्षक प्रक्रियेचे वर्णन केले जाऊ शकते:
  1. जर वाडग्यात सफरचंद असतील तर आम्ही चरण 1.1 ते 1.4 चालवतो:

    1. १.१. एक सफरचंद घ्या
    2. १.२. ते सोलून त्याचे तुकडे करा
    3. १.३. सफरचंदाचे तुकडे कढईत पाई क्रस्टमध्ये व्यवस्थित करा
    4. १.४. पायरी 1 वर परत या.
तर विधान - २समजा तुमच्याकडे दहा सफरचंद, दोन हात आणि एक चाकू आहे. वास्तविक जीवनात, प्रत्येक सफरचंदासाठी समान अल्गोरिदमचे अनुसरण करून, तुम्ही क्रमशः संपूर्ण डझन सोलता. परंतु आपण प्रोग्रामला प्रत्येक सफरचंदासाठी पुनरावृत्तीची क्रिया कशी करावी?
  • आम्ही स्वतःला सफरचंदांच्या संख्येशी जोडतो, परंतु आमच्याकडे ते पुरेसे नसल्यास, काही कमांड "पेलोड" शिवाय अंमलात आणल्या जातील (आणि अस्तित्वात नसलेले सफरचंद सोलण्याचा प्रयत्न करताना आम्ही स्वतःला कापून टाकू शकतो).
  • सोलण्याच्या आदेशापेक्षा जास्त सफरचंद असतील तर काही सफरचंद सोलल्याशिवाय राहतील.
  • असा कोड वाचणे कठीण आहे. यात पुष्कळ पुनरावृत्ती आहेत आणि सुधारणे कठीण आहे.

लूप ही अशी विधाने आहेत जी क्रिया वारंवार करण्याची परवानगी देतात

Java चा while loop आमच्या बाबतीत चांगले काम करेल. ही रचना अनेक क्रिया एका संक्षिप्त आणि समजण्याजोग्या संरचनेत ठेवते. थोडावेळ लूप वापरून , पाईसाठी सफरचंद-स्लाइसिंग अल्गोरिदम Java मध्ये असे दिसू शकते:

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    arrangeInPie(apple.peel().slice());
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");

कमांड सिंटॅक्स

while स्टेटमेंटचा पहिला प्रकार असा आहे:

while (Boolean expression) {
	// Loop body — the statement(s) that are repeatedly executed
}
जेव्हा हा कोड अंमलात आणला जातो तेव्हा काय होते याचे चरण-दर-चरण स्पष्टीकरण येथे आहे:
  1. आम्ही while कीवर्ड नंतर कंसात आढळलेल्या बुलियन अभिव्यक्तीचे मूल्यमापन करतो .
  2. जर बुलियन एक्स्प्रेशनचे मूल्यमापन सत्य असेल, तर लूप बॉडीमधील विधाने कार्यान्वित केली जातात. लूप बॉडीमधील शेवटचे विधान कार्यान्वित झाल्यानंतर, आपण चरण 1 वर जाऊ
  3. जर बुलियन एक्स्प्रेशनचे मूल्यमापन असत्य असेल, तर आपण while लूप नंतरच्या पहिल्या विधानावर जाऊ .

पूर्वस्थितीसह लूप

लूप बॉडी कार्यान्वित करण्यापूर्वी आम्ही नेहमी बूलियन अभिव्यक्ती (लूपमध्ये प्रवेश करण्याची अट) मूल्यमापन करतो , लूपच्या या फॉर्मला अनेकदा पूर्वस्थितीसह लूप म्हणतात . एका संख्येच्या पहिल्या दहा शक्तींचा तक्ता बनवू.

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (exponent <= 10) { // The condition for entering the loop
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
    }
}
कन्सोल आउटपुट:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

पोस्ट कंडिशनसह लूप

या लूपचा दुसरा प्रकार येथे आहे:

do {
    // Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
हा कोड अंमलात आणल्यावर काय होते याचे स्पष्टीकरण येथे आहे:
  1. लूप बॉडी कार्यान्वित केली जाते ( डू कीवर्ड नंतर लगेच).
  2. आम्ही while कीवर्ड नंतर कंसात आढळलेल्या बुलियन अभिव्यक्तीचे मूल्यमापन करतो .
  3. जर बुलियन अभिव्यक्तीचे मूल्यमापन सत्य असेल तर आपण चरण 1 वर जाऊ
  4. जर बुलियन एक्स्प्रेशनचे मूल्यमापन असत्य असेल, तर आपण while लूप नंतरच्या पहिल्या विधानावर जाऊ .
मागील लूपमधील दोन मुख्य फरक आहेत: 1) लूप बॉडी किमान एकदा कार्यान्वित केली जाते आणि 2) लूप बॉडी कार्यान्वित झाल्यानंतर बुलियन अभिव्यक्तीचे मूल्यमापन केले जाते. त्यानुसार, या प्रकारच्या while लूपला पोस्ट कंडिशनसह लूप म्हणतात . यावेळी आम्ही 10000 पेक्षा जास्त नसलेल्या संख्येच्या शक्तींचे सारणी प्रदर्शित करू:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = base; // The result of exponentiation
    int exponent = 1; // The initial exponent
    do {
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        result = result * base;
    } while (result < 10000); // The condition for exiting the loop
}
कन्सोल आउटपुट:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0
कोडमधील बदलांकडे लक्ष द्या. पूर्वस्थितीसह लूपसह याची तुलना करा.

लूपसह काम करण्याबद्दल मनोरंजक तथ्ये

लूप बॉडीमध्ये ब्रॅंचिंग स्टेटमेंट

दोन विधाने आहेत जी लूपमध्ये अंमलबजावणीवर परिणाम करतात: ब्रेक (ज्याबद्दल आपण पुढील अध्यायात अधिक तपशीलवार चर्चा करू) आणि सुरू.
  • सुरू ठेवा — वर्तमान पुनरावृत्तीमध्ये उर्वरित लूप बॉडीची अंमलबजावणी वगळते आणि व्हेल स्टेटमेंटच्या बुलियन अभिव्यक्तीच्या मूल्यमापनाकडे जाते. जर अभिव्यक्तीचे मूल्यमापन खरे असेल, तर लूप चालू राहील.
  • ब्रेक — वर्तमान पुनरावृत्तीची अंमलबजावणी ताबडतोब संपुष्टात आणते आणि लूप नंतर पहिल्या विधानावर नियंत्रण हस्तांतरित करते. अशा प्रकारे, हे विधान वर्तमान लूपची अंमलबजावणी समाप्त करते. आम्ही पुढील लेखात अधिक तपशीलवार विचार करू.
आमचे फळ उदाहरण आठवा. सफरचंदांच्या गुणवत्तेबद्दल आम्हाला खात्री नसल्यास, आम्ही कंटिन्यू स्टेटमेंट वापरून कोड बदलू शकतो:

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
    if (apple.isBad()) { // This method returns true for rotten apples
        apple.throwInGarbage();
        continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
    }
    arrangeInPie(apple.peel().slice());
}
कंटिन्यू स्टेटमेंट अनेकदा वापरले जाते जेव्हा एखादी विशिष्ट स्थिती पूर्ण झाल्यास लूप बॉडीमधील विधाने कार्यान्वित करणे आवश्यक असते. उदाहरणार्थ, हार्डवेअर सेन्सर ट्रिगर झाल्यावर आम्ही क्रिया करू इच्छितो (अन्यथा, आम्ही सेन्सर रीडिंग घेतो तो लूप सुरू ठेवतो) किंवा आम्हाला लूपच्या विशिष्ट पुनरावृत्तीवर अभिव्यक्तीची गणना करायची असेल. नैसर्गिक संख्यांच्या घनांच्या बेरजेची गणना करण्यासाठी आपण while लूपच्या वापरामध्ये नंतरचे उदाहरण पाहिले जाऊ शकते ज्यांचा वर्ग संख्यांच्या संख्येपेक्षा कमी आहे. गोंधळलेला? खालील कोड पहा:

public static void main(String[] args) {
    int sum = 0;  // Total amount
    int i = 0;  // Initial number in the series
    int count = 20;  // Number of numbers
    while (i <= count) {
        i++;  // Get the next number — "i++" is equivalent to "i = i + 1"
        if (i * i <= count)  // If the square of the number is less than
            continue;  // the number of numbers, then we won't calculate the sum
                            // Jump to the next number in the loop
        sum += i * i * i;  // Otherwise, we calculate the sum of the cubes of numbers
    }  // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
    System.out.println(sum);  // Print the result
}

अनंत पळवाट

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

while (true) {
    // Loop body 
}
या प्रकरणात, ब्रेक स्टेटमेंट आम्हाला लूपमधून बाहेर पडण्यास मदत करते. लूपच्या मुख्य भागाच्या बाहेर निर्धारित केलेल्या बाह्य परिस्थितीची प्रतीक्षा करताना या प्रकारचे लूप योग्य आहे. उदाहरणार्थ, ऑपरेटिंग सिस्टम किंवा गेममध्ये (लूपमधून बाहेर पडणे म्हणजे गेममधून बाहेर पडणे). किंवा लूपच्या प्रत्येक पुनरावृत्तीसह, काही परिणाम सुधारण्यासाठी प्रयत्न करणारे अल्गोरिदम वापरताना, परंतु निघून गेलेल्या वेळेवर किंवा बाह्य कार्यक्रमाच्या (उदा. चेकर्स, बुद्धिबळ किंवा हवामान अंदाज) च्या आधारावर पुनरावृत्तीची संख्या मर्यादित करा. लक्षात ठेवा की सामान्य परिस्थितीत अनंत लूप इष्ट नाहीत. प्रदर्शित करण्यासाठी, घातांकाकडे परत जाऊया:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (true) {
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        if (exponent > 10)
            break; // Exit the loop
    }
}
कन्सोल आउटपुट:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

नेस्टेड लूप

आणि आता आपण लूपवरील आपल्या अंतिम विषयावर आलो आहोत. ते सफरचंद पाई (मला आशा आहे की तुम्हाला याक्षणी भूक लागली नसेल) आणि आमची सफरचंद सोलण्याची लूप:
  1. जर वाडग्यात सफरचंद असतील तर आम्ही चरण 1.1 ते 1.4 चालवतो:

    1. १.१. एक सफरचंद घ्या
    2. १.२. ते सोलून त्याचे तुकडे करा
    3. १.३. सफरचंदाचे तुकडे कढईत पाई क्रस्टमध्ये व्यवस्थित करा
    4. १.४. पायरी 1 वर परत या.
स्लाइसिंग प्रक्रियेचे अधिक तपशीलवार वर्णन करूया:
  1. कापांची संख्या = 0
  2. जोपर्यंत स्लाइसची संख्या < 12 आहे, तोपर्यंत 2.1 ते 2.3 पायऱ्या करा

    1. २.१. सफरचंदाचा दुसरा तुकडा कापून घ्या
    2. २.२. स्लाइसची संख्या++
    3. २.३. पायरी 2 वर परत या
आणि आम्ही हे आमच्या पाई-मेकिंग अल्गोरिदममध्ये जोडू:
  1. जर वाडग्यात सफरचंद असतील तर आम्ही चरण 1.1 ते 1.6 कार्यान्वित करतो:

    1. १.१. एक सफरचंद घ्या
    2. १.२. ते सोलून घ्या
    3. १.३. कापांची संख्या = 0
    4. १.४. जोपर्यंत स्लाइसची संख्या < 12 आहे, तोपर्यंत 1.4.1 ते 1.4.3 पायऱ्या करा
      1. १.४.१. सफरचंदाचा दुसरा तुकडा कापून घ्या
      2. १.४.२. स्लाइसची संख्या++
      3. १.४.३. चरण 1.4 वर परत या
    5. 1.5. सफरचंदाचे तुकडे कढईत पाई क्रस्टमध्ये व्यवस्थित करा
    6. १.६. पायरी 1 वर परत या.
आता आपल्याकडे लूपमध्ये एक लूप आहे. अशा रचना अतिशय सामान्य आहेत. अंतिम उदाहरण म्हणून, आपण प्राथमिक शाळेत प्रेम करायला शिकलेल्या गुणाकार सारण्यांपैकी एक तयार करू.

 public static void main(String[] args) {
    // Print the second factors in a row
    System.out.println("    2  3  4  5  6  7  8  9"); 
    int i = 2;  // Assign the first factor to the variable
    while (i < 10) {  // First loop: execute as long as the first factor is less than 10
        System.out.print(i + " | ");  // Print the first factor at the beginning of the line
        int j = 2;  // The starting value of the second factor
        while (j < 10) { // Second loop: execute as long as the second factor is less than 10
            int product = i * j;  // Calculate the product of the factors
            if (product < 10)  // If the product is a single digit, then we print two spaces after the product
                System.out.print(product + "  ");
            else  // Otherwise, print the product and one space after it
                System.out.print(product + " ");
            j++;  // Increment the second factor by one
        }  // Go to the beginning of the second loop, i.e. "while (j < 10)"
        System.out.println();  // Move to the next line on the console
        i++;  // Increment the first factor by one
    } // Go to the beginning of the first loop, i.e. "while (i < 10)"
}
कन्सोल आउटपुट:

    2  3  4  5  6  7  8  9
2 | 4 6 8 10 12 14 16 18
3 | 6 9 12 15 18 21 24 27
4 | 8 12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81
Process finished with exit code 0
लूप (विशेषतः, जबकि स्टेटमेंट) हे सॉफ्टवेअरच्या मूलभूत बिल्डिंग ब्लॉक्सपैकी एक आहेत. CodeGym वरील कार्ये सोडवून, तुम्ही सर्व विविध प्रकारचे लूप शिकाल, त्यांची गुंतागुंत समजून घ्याल आणि त्यांचा वापर करण्याचे व्यावहारिक कौशल्य प्राप्त कराल.