Looping i programmeringsspråk er en funksjon som letter utføringen av et sett med instruksjoner/funksjoner gjentatte ganger mens noen tilstand evalueres til sann. Java gir tre måter å utføre løkkene på. Mens alle måtene gir lignende grunnleggende funksjonalitet, er de forskjellige i syntaks og tilstandskontrolltid.
java gir tre typer betingede setninger, denne andre typen er loop-setning.
- mens loop: En while-løkke er en kontrollflytsetning som lar kode utføres gjentatte ganger basert på en gitt boolsk tilstand. While-løkken kan betraktes som en repeterende if-setning.
Syntaks:
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++;> >}> >}> }> |
>
>Produksjon
a-b beskjæring
0 1 2 3 4 5 6 7 8 9 10>
- Flytskjema:
- Mens loop starter med sjekk av boolsk tilstand. Hvis den ble evaluert til sann, kjøres loop body-setningene, ellers kjøres den første setningen etter loopen. Av denne grunn kalles det også Entry control loop
- Når betingelsen er evaluert til sann, utføres setningene i loop-kroppen. Normalt inneholder setningene en oppdateringsverdi for variabelen som behandles for neste iterasjon.
- Når tilstanden blir falsk, avsluttes sløyfen som markerer slutten på livssyklusen.
- for loop: for loop gir en kortfattet måte å skrive loopstrukturen på. I motsetning til en while-løkke, bruker en for-setning initialiseringen, tilstanden og økningen/dekrementeringen på én linje, og gir dermed en kortere struktur for looping som er lett å feilsøke.
Syntaks:
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);> >}> >}> }> |
>
>Produksjon
0 1 2 3 4 5 6 7 8 9 10>
- Flytskjema:
- Initialiseringsbetingelse: Her initialiserer vi variabelen som er i bruk. Det markerer starten på en for-løkke. En allerede erklært variabel kan brukes eller en variabel kan deklareres, kun lokal til loop. Testtilstand: Den brukes til å teste utgangstilstanden for en sløyfe. Den må returnere en boolsk verdi. Det er også en Entry Control Loop ettersom tilstanden kontrolleres før kjøringen av loop-setningene. Utførelse av utsagn: Når betingelsen er evaluert til sann, utføres utsagnene i loop-kroppen. Inkrement/reduksjon: Den brukes til å oppdatere variabelen for neste iterasjon. Sløyfeavslutning: Når tilstanden blir falsk, avsluttes sløyfen og markerer slutten på livssyklusen.
- gjør mens: do while loop ligner while loop med den eneste forskjellen at den sjekker for tilstand etter å ha utført setningene, og er derfor et eksempel på Avslutt kontrollsløyfe.
Syntaks:
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>);> >}> }> |
>
>Produksjon
0 1 2 3 4 5 6 7 8 9 10>
- Flytskjema:
- do while loop starter med utførelsen av setningen(e). Det er ingen kontroll av noen tilstand for første gang.
- Etter utførelse av setningene, og oppdatering av variabelverdien, sjekkes betingelsen for sann eller usann verdi. Hvis den vurderes til sann, starter neste iterasjon av loopen.
- Når tilstanden blir falsk, avsluttes sløyfen som markerer slutten på livssyklusen.
- Det er viktig å merke seg at do-while-sløyfen vil utføre setningene sine minst én gang før noen betingelse kontrolleres, og er derfor et eksempel på exit control loop.
Fallgruvene til Loops
- Uendelig sløyfe: En av de vanligste feilene når du implementerer noen form for sløyfe, er at den kanskje aldri avsluttes, det vil si at løkken går i uendelig tid. Dette skjer når tilstanden svikter av en eller annen grunn. Eksempler: Infinite for loop :
Java
/*package whatever //do not write package name here */> import> java.io.*;> class> GFG {> >public> static> void> main(String[] args)> >{> >for> (;;) {> >}> >}> }> |
>
>
uendelig mens loop:
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');> >}> >}> }> |
>
>
En annen fallgruve er at du kanskje legger til noe i samlingsobjektet ditt gjennom loop, og du kan gå tom for minne. Hvis du prøver å kjøre programmet nedenfor, vil unntaket for tom minne etter en stund bli kastet.
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); } } }> |
>
>
Produksjon:
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)>
Nestet sløyfe:
Nested loop betyr en loop-setning inne i en annen loop-setning.
Det er forskjellige kombinasjoner av løkke ved hjelp av til Løkke, samtidig som Løkke, gjør mens Løkke.
Eks.1 Nestet for løkke
Java
javascript kommentar
lag et sh-skript kjørbart
/*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();> >}> >}> }> |
>
>Produksjon
0 0 1 1 2 2>
Eks.2 Nestet mens-løkke
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>;> >}> >}> }> |
>
>Produksjon
123 123 123>
Eks.3 Nested do while loop
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>= rad);> >column =>1>;> >do> {> >System.out.print(column +>' '>);> >column++;> >}>while> (column <=>5>);> >System.out.println(>' '>);> >row++;> >}>while> (row <=>5>);> >}> }> |
>
>Produksjon
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>
Eks.4 Nestet mens og for loop
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;> >}> >}> }> |
>
>Produksjon
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>