Java >> Java tutorial >  >> Tag >> break

Bryde ud af indlejrede løkker

break

1. Oversigt

I denne øvelse vil vi lave nogle eksempler for at vise forskellige måder at bruge pause på inden for en løkke. Dernæst skal vi også se, hvordan du afslutter en loop uden at bruge pause overhovedet.

2. Problemet

Indlejrede sløjfer er meget nyttige, for eksempel til at søge i en liste over lister.

Et eksempel kunne være en liste over studerende, hvor hver elev har en liste over planlagte kurser. Lad os sige, at vi vil finde navnet på én person, der planlagde kursus 0 .

Først ville vi gennemgå listen over elever. Derefter, inde i den løkke, ville vi sløjfe over listen over planlagte kurser.

Når vi udskriver navnene på eleverne og kurserne, får vi følgende resultat:

student 0
  course 0
  course 1
student 1
  course 0
  course 1

Vi ville finde den første elev, der planlagde kursus 0 . Men hvis vi bare bruger loops, vil applikationen fortsætte med at søge, efter at kurset er fundet.

Når vi har fundet en person, der har planlagt det specifikke kursus, vil vi stoppe med at søge. At fortsætte med at søge ville tage mere tid og ressourcer, mens vi ikke har brug for de ekstra oplysninger. Det er derfor, vi vil bryde ud af den indlejrede løkke.

3. Pause

Den første mulighed, vi har for at gå ud af en indlejret løkke, er simpelthen at bruge pausen erklæring:

String result = "";
for (int outerCounter = 0; outerCounter < 2; outerCounter++) {
    result += "outer" + outerCounter;
    for (int innerCounter = 0; innerCounter < 2; innerCounter++) {
        result += "inner" + innerCounter;
        if (innerCounter == 0) {
            break;
        }
    }
}
return result;

Vi har en ydre løkke og en indre løkke, begge løkker har to iterationer. Hvis tælleren for den indre løkke er lig med 0, udfører vi pausen kommando. Når vi kører eksemplet, vil det vise følgende resultat:

outer0inner0outer1inner0

Eller vi kunne justere koden for at gøre den lidt mere læsbar:

outer 0
  inner 0
outer 1
  inner 0

Er det det, vi ønsker?

Næsten den indre løkke afsluttes af break-sætningen efter 0 er fundet. Den ydre løkke fortsætter dog, hvilket ikke er det vi ønsker. Vi ønsker at stoppe behandlingen fuldstændigt, så snart vi har svaret.

4. Mærket Break

Det forrige eksempel var et skridt i den rigtige retning, men vi skal forbedre det lidt. Det kan vi gøre ved at bruge en mærket pause :

String result = "";
myBreakLabel:
for (int outerCounter = 0; outerCounter < 2; outerCounter++) {
    result += "outer" + outerCounter;
    for (int innerCounter = 0; innerCounter < 2; innerCounter++) {
        result += "inner" + innerCounter;
        if (innerCounter == 0) {
            break myBreakLabel;
        }
    }
}
return result;

En mærket break vil afslutte den ydre løkke i stedet for kun den indre løkke. Det opnår vi ved at tilføje myBreakLabel uden for løkken og ændre break-sætningen til stopmyBreakLabel . Når vi har kørt eksemplet, får vi følgende resultat:

outer0inner0

Vi kan læse det lidt bedre med noget formatering:

outer 0
  inner 0

Hvis vi ser på resultatet kan vi se, at både den indre løkke og den ydre løkke er afsluttet, hvilket er, hvad vi ønskede at opnå.

5. Retur

Som et alternativ kunne vi også bruge retur sætning for at returnere resultatet direkte, når det er fundet:

String result = "";
for (int outerCounter = 0; outerCounter < 2; outerCounter++) {
    result += "outer" + outerCounter;
    for (int innerCounter = 0; innerCounter < 2; innerCounter++) {
        result += "inner" + innerCounter;
        if (innerCounter == 0) {
            return result;
        }
    }
}
return "failed";

Etiketten fjernes og pausen erklæringen erstattes af en retur erklæring.

Når vi udfører koden ovenfor, får vi det samme resultat som for den mærkede pause. Bemærk, at for at denne strategi skal fungere, skal vi typisk flytte blokken af ​​sløjfer til sin egen metode.

6. Konklusion

Så vi har lige kigget på, hvad vi skal gøre, når vi skal forlade en løkke tidligt, som når vi har fundet den vare, vi leder efter. pausen nøgleordet er nyttigt for enkelte sløjfer, og vi kan bruge mærket break s for indlejrede løkker.

Alternativt kan vi bruge et retur erklæring. Brug af retur gør koden bedre læsbar og mindre fejltilbøjelig, da vi ikke behøver at tænke på forskellen mellem umærkede og mærkede brud.

Tag gerne et kig på koden på GitHub.


Java tag