Java Habang Loop

Ang while loop ay matatagpuan sa halos lahat ng programming language, at ang Java ay walang exception. Habang ang loop sa Java at iba pang mga wika ay nagsasagawa ng isang pahayag o bloke ng mga pahayag hangga't ang halaga ng kundisyon na nag-trigger nito ay totoo. Sa artikulong ito, pag-uusapan natin kung paano gamitin ang while loop.

Para saan ang mga cycle?

Ang iyong pinakaunang mga programa ay isang pagkakasunud-sunod ng mga tagubilin na naisakatuparan nang sunud-sunod. Nang walang mga tinidor at pag-uulit. Nang maglaon ay nagsimula kaming gumamit ng mga sangay sa tulong ng mga conditional operator. Buweno, upang maisagawa ang mga paulit-ulit na aksyon, may mga cycle. Marahil ang mga cycle ay isa sa mga pinaka-halatang benepisyo sa mga baguhang programmer na ibinibigay ng automation ng proseso. Isipin na kailangan mong magsulat ng isang tracker program na binibilang ang bilang ng mga hakbang na ginawa sa isang araw. At kapag pumasa ka, halimbawa, 10,000 hakbang, dapat magpadala sa iyo ang programa ng abiso tungkol sa nakamit na layunin. Ang gawain ng pagbibigay ng abiso ay maaaring ipahayag sa mga salita (o pseudocode) tulad nito:

While (number of steps less than 10,000)
{
Count steps
}

Send notification "you have reached the goal"

Iyon ay, sa sandaling ang bilang ng mga hakbang ay katumbas ng kung ano ang tinukoy sa kondisyon, ang programa ay lalabas sa cycle na ito at nagpapadala ng isang abiso. O isa pang halimbawa. Isipin na kailangan mong isaulo ang isang tula (o talumpati). Itinuturing na kabisado ang isang tula kung mababasa mo ito nang tatlong beses nang sunud-sunod nang hindi nakasilip. Kung iniisip mo ang isang programa na kumukuha ng iyong mga pagtatangka na bigkasin ang isang tula, kakailanganin din nitong gumamit ng isang loop:

While (success < 3)
learn a poem

Ang mga katulad na construction ay ginagamit sa lahat ng modernong pang-edukasyon na app na ginagamit, halimbawa, sa pag-aaral ng mga wika o pagtugtog ng mga instrumentong pangmusika.

Habang ang loop at ang istraktura nito

Upang malutas ang mga problema tulad ng mga halimbawa sa itaas, at higit sa pangkalahatan, upang i-automate ang mga paulit-ulit na pagkilos sa Java, maaari mong gamitin ang while loop. Ang Java while loop ay gagana nang maayos sa aming kaso. Ang disenyong ito ay nag-aayos ng maraming aksyon sa isang maigsi at naiintindihan na istraktura. Ang while loop statement ay matatagpuan sa halos lahat ng programming language. Inuulit nito ang isang pahayag o bloke ng mga pahayag hangga't ang halaga ng control expression nito ay totoo. Ang anyo ng while loop ay ang mga sumusunod:

while(condition == true) {
    // statement or loop body
}

Ang kundisyon ay dapat na isang boolean na expression, iyon ay, isa na masasabing totoo o mali. Narito ang ilang halimbawa ng mga boolean na expression:

s != "exit";
a > 5;
true;

Ang katawan ng loop ay isasagawa hangga't ang conditional expression ay totoo. Kapag naging false ang kundisyon, ililipat ang kontrol sa linya ng code na darating pagkatapos ng loop. Kung isang pahayag lamang ang ginagamit sa loop, kung gayon ang mga kulot na braces ay maaaring tanggalin (ngunit mas mahusay na huwag gawin ito). Ang lohikal na expression ay sinusuri bago ang simula ng while loop, at pagkatapos ay sa bawat oras bago ang susunod na pag-uulit ng pahayag ay naisakatuparan.

Habang Mga Halimbawa ng Loop

Sumulat tayo ng isang programa upang mabuo ang lahat ng mga numero mula 1 hanggang 10 gamit ang isang while loop:

public class WhileTest0 {
   public static void main(String[] args) {
       int i = 0;
       int sum = 0;
   //while loop     
   while (i < 11) {
           sum = sum + i;
           i++;
       }
       System.out.println(sum);
   }
}

Ang output ay: Kailangan nating kalkulahin ang kabuuan ng lahat ng mga numero mula 1 (o mula sa zero, hindi mahalaga) hanggang 10. Ginagawa natin ang paunang kabuuan at ang unang elemento na katumbas ng zero, at dadagdagan natin ang elemento ng isa sa bawat pass ng ang loop. Patuloy kaming magsusuma hanggang ang argumento ay maging katumbas ng 10 (iyon ay, mas mababa sa 11. Katulad nito, maaari naming isulat ang kundisyon i <= 10 ). Kumuha tayo ng isa pang halimbawa ng Java while loop. Magsusulat kami ng isang programa kung saan ang mga gumagamit ay naglalagay ng mga positibong integer. Kung maglagay sila ng zero o negatibong numero, dapat itong iulat ng programa at tapusin ang trabaho.

import java.util.Scanner;

public class WhileTest {
   public static void main(String[] args) {
       int positiveNumber = 1;
       Scanner scanner = new Scanner(String.valueOf(positiveNumber));
       while (positiveNumber > 0) {
           Scanner sc = new Scanner(System.in);
           System.out.println("Enter positive number:");
           positiveNumber = sc.nextInt();
           System.out.println("ok, next");
       }
       System.out.println("The number should be positive");
   }
}

Maaari mong pagbutihin ang program at idagdag dito, halimbawa, pagsuri kung eksaktong numero ang ipinasok ng user at hindi ibang character, o ang numero ay isang integer.

do-while loop

Ang classic na while loop, tulad ng sa mga halimbawa sa itaas, ay agad na nagsusuri upang makita kung totoo ang kundisyon. Samakatuwid, maaari itong tawaging isang cycle na may precondition. Ang while loop ay may kapatid na do-while, isang loop na may postcondition. Iyon ay, bago mangyari ang pagsubok ng katotohanan ng kondisyon, ang naturang loop ay isasagawa nang hindi bababa sa isang beses:

do {
     // Loop body - periodically executed statement(s)
}while(Boolean expression);

Kaya, ang unang halimbawa na may tulad na isang loop ay magiging ganito:

public class WhileTest0 {
   public static void main(String[] args) {
       int i = 0;
       int sum = 0;
       do
        {
           sum = sum + i;
           i++;
       } while (i < 11);
       System.out.println(sum);
   }
}

Walang katapusang cycle

Ang while loop ay maaaring gamitin upang ayusin ang walang katapusan na mga loop sa form while(true) : Halimbawa, narito ang isang programa na walang katapusang (na may ilang mga nuances) na nagpi-print ng isang serye ng mga integer:

public class EndlessLoop {
    public static void main(String[] args) {
        int i = 0;
        while (true) {
            System.out.println(i++);
        }
    }
}

Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course