Cilpu veidošana programmēšanas valodās ir līdzeklis, kas atvieglo instrukciju/funkciju kopas izpildi atkārtoti, kamēr daži nosacījumi tiek novērtēti kā patiesi. Java nodrošina trīs veidus, kā izpildīt cilpas. Lai gan visi veidi nodrošina līdzīgu pamata funkcionalitāti, tie atšķiras pēc sintakses un stāvokļa pārbaudes laika.
java nodrošina trīs veidu nosacījuma paziņojumus, šis otrais veids ir cilpas paziņojums.
- kamēr cilpa: Kamēr cilpa ir vadības plūsmas paziņojums, kas ļauj atkārtoti izpildīt kodu, pamatojoties uz noteiktu Būla nosacījumu. Ciklu while var uzskatīt par atkārtotu if paziņojumu.
Sintakse :
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++;> >}> >}> }> |
>
>Izvade
0 1 2 3 4 5 6 7 8 9 10>
- Blokshēma:
- Kamēr cilpa sākas ar Būla stāvokļa pārbaudi. Ja tas tiek novērtēts kā patiess, tad tiek izpildīti cilpas pamatteksta paziņojumi, pretējā gadījumā tiek izpildīts pirmais paziņojums pēc cilpas. Šī iemesla dēļ to sauc arī par Ieejas vadības cilpa
- Kad nosacījums ir novērtēts kā patiess, tiek izpildīti priekšraksti cilpas pamattekstā. Parasti priekšraksti satur atjaunināšanas vērtību mainīgajam, kas tiek apstrādāts nākamajai iterācijai.
- Kad nosacījums kļūst nepatiess, cilpa beidzas, kas iezīmē tā dzīves cikla beigas.
- cilpai: for loop nodrošina īsu veidu, kā rakstīt cilpas struktūru. Atšķirībā no while cilpas, priekšraksts for patērē inicializēšanu, nosacījumu un palielināšanu/samazināšanu vienā rindā, tādējādi nodrošinot īsāku, viegli atkļūdojamu cilpas struktūru.
Sintakse:
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);> >}> >}> }> |
>
>Izvade
0 1 2 3 4 5 6 7 8 9 10>
- Blokshēma:
- Inicializācijas nosacījums: šeit mēs inicializējam izmantoto mainīgo. Tas iezīmē for cilpas sākumu. Var izmantot jau deklarētu mainīgo vai var deklarēt mainīgo, tikai lokālajā ciklā. Testēšanas nosacījums: to izmanto, lai pārbaudītu cilpas izejas nosacījumu. Tam ir jāatgriež Būla vērtība. Tas ir arī an Ieejas kontroles cilpa jo nosacījums tiek pārbaudīts pirms cilpas priekšrakstu izpildes. Paziņojuma izpilde: kad nosacījums ir novērtēts kā patiess, tiek izpildīti priekšraksti cilpas pamattekstā. Palielināt/samazināt: to izmanto mainīgā atjaunināšanai nākamajai iterācijai. Cikla pārtraukšana: kad nosacījums kļūst nepatiess, cilpa beidzas, atzīmējot tā dzīves cikla beigas.
- darīt kamēr: do while cilpa ir līdzīga while cilpai ar tikai atšķirību, ka tā pārbauda stāvokli pēc priekšrakstu izpildes, un tāpēc ir piemērs Iziet no vadības cilpas.
Sintakse:
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>);> >}> }> |
>
>Izvade
0 1 2 3 4 5 6 7 8 9 10>
- Blokshēma:
- do while cilpa sākas ar priekšraksta(-u) izpildi. Pirmo reizi netiek pārbaudīts neviens stāvoklis.
- Pēc paziņojumu izpildes un mainīgā vērtības atjaunināšanas nosacījumam tiek pārbaudīta patiesa vai nepatiesa vērtība. Ja tas tiek novērtēts kā patiess, sākas nākamā cilpas iterācija.
- Kad nosacījums kļūst nepatiess, cilpa beidzas, kas iezīmē tā dzīves cikla beigas.
- Ir svarīgi atzīmēt, ka do-while cilpa izpildīs savus paziņojumus vismaz vienu reizi pirms jebkura nosacījuma pārbaudes, un tāpēc tas ir izejas vadības cilpas piemērs.
Cilpu kļūmes
- Bezgalīga cilpa: viena no visizplatītākajām kļūdām, ieviešot jebkāda veida cilpas, ir tā, ka tā var nekad neiziet, tas ir, cilpa darbojas bezgalīgi. Tas notiek, ja stāvoklis kāda iemesla dēļ neizdodas. Piemēri: Infinite for loop :
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >for> (;;) {> >}> >}> }> |
>
>
bezgalīga kamēr cilpa:
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');> >}> >}> }> |
>
>
Vēl viena kļūme ir tāda, ka jūs, iespējams, pievienojat kaut ko savā kolekcijas objektam, izmantojot cilpu, un jums var pietrūkt atmiņas. Ja mēģināsit izpildīt tālāk norādīto programmu, pēc kāda laika tiks izmests izņēmums no atmiņas.
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); } } }> |
>
>
Izvade:
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)>
Ligzdota cilpa:
Ligzdota cilpa nozīmē cilpas priekšrakstu citā cilpas priekšrakstā.
Ir dažādas cilpas izmantošanas kombinācijas priekš cilpa, kamēr cilpa, darīt kamēr cilpa.
Piemēram, 1. ligzdota cilpai
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 <>3>; i++){> >for>(>int> j =>0>; j <>2>; j++){> >System.out.println(i);> >}> >System.out.println();> >}> >}> }> |
>
>Izvade
0 0 1 1 2 2>
Piemēram, 2. ligzdota cilpa
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>;> >}> >}> }> |
>
>Izvade
123 123 123>
Piemēram, 3. ligzdota do while cilpa
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>= rinda);> >column =>1>;> >do> {> >System.out.print(column +>' '>);> >column++;> >}>while> (column <=>5>);> >System.out.println(>' '>);> >row++;> >}>while> (row <=>5>);> >}> }> |
>
>Izvade
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>
Piem., 4. ligzdots while un for cilpa
Java
ankita Deivs
/*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;> >}> >}> }> |
>
>Izvade
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>