Looping i programmeringssprog er en funktion, som letter udførelsen af et sæt instruktioner/funktioner gentagne gange, mens nogle tilstande vurderes til at være sande. Java giver tre måder at udføre loops på. Selvom alle måder giver lignende grundlæggende funktionalitet, adskiller de sig i deres syntaks og tilstandskontroltid.
java giver tre typer betingede sætninger, denne anden type er loop-sætning.
- mens loop: En while-løkke er en kontrolflow-sætning, der tillader, at kode udføres gentagne gange baseret på en given boolsk tilstand. While-løkken kan opfattes som en repeterende if-sætning.
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++;> >}> >}> }> |
>
>Produktion
a-b beskæring
0 1 2 3 4 5 6 7 8 9 10>
- Flowchart:
- Mens loop starter med kontrol af boolsk tilstand. Hvis den evalueres til sand, udføres loop body-sætningerne, ellers udføres den første sætning efter løkken. Af denne grund kaldes det også Indgangskontrolsløjfe
- Når betingelsen er evalueret til sand, udføres sætningerne i loop-kroppen. Normalt indeholder sætningerne en opdateringsværdi for den variabel, der behandles til næste iteration.
- Når betingelsen bliver falsk, afsluttes løkken, hvilket markerer afslutningen på dens livscyklus.
- til sløjfe: for loop giver en kortfattet måde at skrive loopstrukturen på. I modsætning til en while-løkke forbruger en for-sætning initialiseringen, betingelsen og stigningen/nedsættelsen på én linje og giver derved en kortere, let at fejlsøge struktur for looping.
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);> >}> >}> }> |
>
>Produktion
0 1 2 3 4 5 6 7 8 9 10>
- Flowchart:
- Initialiseringsbetingelse: Her initialiserer vi variablen i brug. Det markerer starten på en for-løkke. En allerede erklæret variabel kan bruges, eller en variabel kan erklæres, kun lokal til sløjfe. Testtilstand: Den bruges til at teste udgangstilstanden for en sløjfe. Den skal returnere en boolesk værdi. Det er også en Entry Control Loop da betingelsen kontrolleres før udførelse af loop-sætningerne. Udførelse af erklæring: Når betingelsen er evalueret til sand, udføres sætningerne i loop-kroppen. Increment/Decrement: Det bruges til at opdatere variablen til næste iteration. Sløjfeterminering: Når betingelsen bliver falsk, afsluttes løkken og markerer afslutningen på dens livscyklus.
- gøre imens: do while loop ligner while loop med den eneste forskel, at den kontrollerer for tilstand efter udførelse af sætningerne, og er derfor et eksempel på Afslut kontrolsløjfe.
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>);> >}> }> |
>
>Produktion
0 1 2 3 4 5 6 7 8 9 10>
- Flowchart:
- do while loop starter med udførelsen af sætningen/sætningerne. Der er ingen kontrol af nogen tilstand for første gang.
- Efter udførelse af sætningerne og opdatering af variabelværdien kontrolleres betingelsen for sand eller falsk værdi. Hvis den vurderes til sand, starter næste iteration af loop.
- Når betingelsen bliver falsk, afsluttes løkken, hvilket markerer afslutningen på dens livscyklus.
- Det er vigtigt at bemærke, at do-while-løkken vil udføre sine sætninger mindst én gang, før nogen betingelse kontrolleres, og derfor er et eksempel på exit-kontrolløkke.
Faldgruber af loops
- Uendelig sløjfe: En af de mest almindelige fejl ved implementering af enhver form for looping er, at den måske aldrig afsluttes, det vil sige, at løkken kører i uendelig tid. Dette sker, når tilstanden fejler af en eller anden grund. 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-løkke:
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 anden faldgrube er, at du måske tilføjer noget til dit samlingsobjekt gennem loop, og du kan løbe tør for hukommelse. Hvis du prøver at udføre nedenstående program, vil der efter et stykke tid blive smidt en undtagelse fra hukommelsen.
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); } } }> |
>
>
Produktion:
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)>
Indlejret sløjfe:
Indlejret loop betyder en loop-sætning inde i en anden loop-sætning.
Der er forskellige kombinationer af loop ved hjælp af til sløjfe, mens sløjfe, gøre imens sløjfe.
Eks.1 Indlejret til sløjfe
Java
javascript kommentar
lav et sh-script eksekverbart
/*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();> >}> >}> }> |
>
>Produktion
0 0 1 1 2 2>
Eks.2 Indlejret 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>;> >}> >}> }> |
>
>Produktion
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>= række);> >column =>1>;> >do> {> >System.out.print(column +>' '>);> >column++;> >}>while> (column <=>5>);> >System.out.println(>' '>);> >row++;> >}>while> (row <=>5>);> >}> }> |
>
>Produktion
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 Indlejret 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;> >}> >}> }> |
>
>Produktion
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>