Silmukka ohjelmointikielissä on ominaisuus, joka helpottaa käskyjen/toimintojen suorittamista toistuvasti, kun taas jotkin olosuhteet muuttuvat todeksi. Java tarjoaa kolme tapaa suorittaa silmukoita. Vaikka kaikki tavat tarjoavat samanlaisia perustoimintoja, ne eroavat syntaksista ja kunnontarkistusajasta.
java tarjoaa kolmenlaisia ehdollisia lausekkeita, tämä toinen tyyppi on silmukkalause.
- while-silmukka: While-silmukka on ohjausvuon käsky, joka sallii koodin suorittamisen toistuvasti tietyn Boolen ehdon perusteella. While-silmukkaa voidaan pitää toistuvana if-lauseena.
Syntaksi :
while (boolean condition) { loop statements... }> Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >int> i=>0>;> >while> (i<=>10>)> >{> >System.out.println(i);> >i++;> >}> >}> }> |
>
>Lähtö
0 1 2 3 4 5 6 7 8 9 10>
- Vuokaavio:
- While-silmukka alkaa Boolen ehdon tarkistuksella. Jos se arvioidaan tosi, silmukan runkolauseet suoritetaan muuten silmukkaa seuraava ensimmäinen lauseke suoritetaan. Tästä syystä sitä kutsutaan myös Sisääntulon ohjaussilmukka
- Kun ehto on arvioitu todeksi, silmukan rungon lauseet suoritetaan. Yleensä käskyt sisältävät päivitysarvon käsiteltävälle muuttujalle seuraavaa iteraatiota varten.
- Kun ehdosta tulee epätosi, silmukka päättyy, mikä merkitsee sen elinkaaren loppua.
- silmukalle: for loop tarjoaa tiiviin tavan kirjoittaa silmukkarakenne. Toisin kuin while-silmukka, for-käsky kuluttaa alustuksen, ehdon ja lisäyksen/vähennyksen yhdellä rivillä, mikä tarjoaa lyhyemmän, helposti korjattavan silmukan rakenteen.
Syntaksi:
for (initialization condition; testing condition;increment/decrement) { statement(s) }> Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >for> (>int> i=>0>;i<=>10>;i++)> >{> >System.out.println(i);> >}> >}> }> |
>
>Lähtö
0 1 2 3 4 5 6 7 8 9 10>
- Vuokaavio:
- Alustusehto: Tässä alustetaan käytössä oleva muuttuja. Se merkitsee for-silmukan alkua. Jo ilmoitettua muuttujaa voidaan käyttää tai muuttuja voidaan ilmoittaa, vain paikallissilmukalle. Testausehto: Sitä käytetään silmukan poistumisehdon testaamiseen. Sen on palautettava looginen arvo. Se on myös an Sisääntulon ohjaussilmukka koska ehto tarkistetaan ennen silmukkakäskyjen suorittamista. Lausekkeen suoritus: Kun ehto on arvioitu todeksi, silmukan rungossa olevat lauseet suoritetaan. Increment/Decrement: Sitä käytetään muuttujan päivittämiseen seuraavaa iteraatiota varten. Silmukan päättäminen: Kun ehdosta tulee epätosi, silmukka päättyy ja merkitsee sen elinkaaren loppua.
- tehdä, kun: do while -silmukka on samankaltainen kuin while-silmukka sillä erolla, että se tarkistaa ehdon lauseiden suorittamisen jälkeen ja on siksi esimerkki Poistu ohjaussilmukasta.
Syntaksi:
do { statements.. } while (condition);> Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >int> i=>0>;> >do> >{> >System.out.println(i);> >i++;> >}>while>(i<=>10>);> >}> }> |
>
>Lähtö
0 1 2 3 4 5 6 7 8 9 10>
- Vuokaavio:
- do while -silmukka alkaa lauseen (käskyjen) suorittamisesta. Mitään kuntoa ei tarkisteta ensimmäistä kertaa.
- Lausekkeiden suorittamisen ja muuttujan arvon päivityksen jälkeen ehdon arvo tarkistetaan tosi tai epätosi. Jos sen arvoksi arvioidaan tosi, seuraava silmukan iteraatio alkaa.
- Kun ehdosta tulee epätosi, silmukka päättyy, mikä merkitsee sen elinkaaren loppua.
- On tärkeää huomata, että do-while-silmukka suorittaa käskynsä ainakin kerran ennen kuin mikä tahansa ehto tarkistetaan, ja siksi se on esimerkki poistumisohjaussilmukasta.
Loopsin sudenkuopat
- Infinite loop: Yksi yleisimmistä virheistä kaikenlaisen silmukan toteutuksessa on, että se ei ehkä koskaan poistu, eli silmukka toimii äärettömän ajan. Tämä tapahtuu, kun tila epäonnistuu jostain syystä. Esimerkkejä: Infinite for loop :
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >for> (;;) {> >}> >}> }> |
>
>
ääretön while-silmukka:
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >while> (>true>)> >{> >// statement> >}> > >}> }> |
>
>
Java
//Java program to illustrate various pitfalls.> public> class> LooppitfallsDemo> {> >public> static> void> main(String[] args)> >{> >// infinite loop because condition is not apt> >// condition should have been i>0.> >for> (>int> i =>5>; i !=>0>; i -=>2>)> >{> >System.out.println(i);> >}> >int> x =>5>;> >// infinite loop because update statement> >// is not provided.> >while> (x ==>5>)> >{> >System.out.println('In the loop');> >}> >}> }> |
>
>
Toinen sudenkuoppa on, että saatat lisätä jotain kokoelmaobjektiin silmukan kautta ja muisti voi loppua. Jos yrität suorittaa alla olevan ohjelman, jonkin ajan kuluttua poistetaan muistin loppumisesta poikkeus.
Java
//Java program for out of memory exception.> import> java.util.ArrayList;> public> class> Integer1> {> >public> static> void> main(String[] args)> >{> >ArrayList ar =>new> ArrayList();> >for> (>int> i =>0>; i { ar.add(i); } } }> |
>
>
Lähtö:
Exception in thread 'main' java.lang.OutOfMemoryError: Java heap space at java.util.Arrays.copyOf(Unknown Source) at java.util.Arrays.copyOf(Unknown Source) at java.util.ArrayList.grow(Unknown Source) at java.util.ArrayList.ensureCapacityInternal(Unknown Source) at java.util.ArrayList.add(Unknown Source) at article.Integer1.main(Integer1.java:9)>
Sisäkkäinen silmukka:
Sisäkkäinen silmukka tarkoittaa silmukkakäskyä toisen silmukkakäskyn sisällä.
On olemassa erilaisia silmukkayhdistelmiä varten silmukka, sillä aikaa silmukka, tehdä, kun silmukka.
Esim.1 Sisäkkäinen silmukalle
Java
polymorfismi javassa
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main (String[] args) {> >for>(>int> i =>0>; i <>3>; i++){> >for>(>int> j =>0>; j <>2>; j++){> >System.out.println(i);> >}> >System.out.println();> >}> >}> }> |
>
>Lähtö
0 0 1 1 2 2>
Esim.2 Sisäkkäinen while-silmukka
Java
import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> i =>1>, j =>1>;> >while> (i <=>3>) {> >while> (j <=>3>) {> >System.out.print(j);> >j++;> >}> >i++;> >System.out.println(>''>);> >j =>1>;> >}> >}> }> |
>
>Lähtö
123 123 123>
Esim.3 Sisäkkäinen do while -silmukka
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> row =>1>, column =>1>;> >int> x;> >do> {> >x =>4>;> >do> {> >System.out.print(>''>);> >x--;> >}>while> (x>= rivi);> >column =>1>;> >do> {> >System.out.print(column +>' '>);> >column++;> >}>while> (column <=>5>);> >System.out.println(>' '>);> >row++;> >}>while> (row <=>5>);> >}> }> |
>
>Lähtö
1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5>
Esim.4 Sisäkkäinen while- ja for-silmukka
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >int> weeks =>3>;> >int> days =>7>;> >int> i =>1>;> >// outer loop> >while> (i <= weeks) {> >System.out.println(>'Week: '> + i);> >// inner loop> >for> (>int> j =>1>; j <= days; ++j) {> >System.out.println(>' Days: '> + j);> >}> >++i;> >}> >}> }> |
>
>Lähtö
Week: 1 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7 Week: 2 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7 Week: 3 Days: 1 Days: 2 Days: 3 Days: 4 Days: 5 Days: 6 Days: 7>