streamalism.org

1. Overzicht

In deze zelfstudie maken we enkele voorbeelden om verschillende manieren van gebruik te laten zien breken binnen een lus. Vervolgens zullen we ook zien hoe u een lus kunt beëindigen zonder breken helemaal.

2. Het probleem

Geneste lussen zijn bijvoorbeeld erg handig om in een lijst met lijsten te zoeken.

Een voorbeeld is een lijst met studenten, waarbij elke student een lijst met geplande cursussen heeft. Laten we zeggen dat we de naam willen vinden van een persoon die heeft gepland cursus 0.

Eerst liepen we door de lijst met studenten. Dan, binnen die lus, zouden we de lijst met geplande cursussen doorlopen.

Als we de namen van de studenten en cursussen afdrukken, krijgen we het volgende resultaat:

student 0 cursus 0 cursus 1 student 1 cursus 0 cursus 1

We wilden de eerste student vinden die van plan was cursus 0. Als we echter alleen loops gebruiken, zal de applicatie doorgaan met zoeken nadat de cursus is gevonden.

Nadat we een persoon hebben gevonden die de specifieke cursus heeft gepland, we willen stoppen met zoeken. Doorgaan met zoeken zou meer tijd en middelen vergen, terwijl we de extra informatie niet nodig hebben. Daarom willen we breken uit de geneste lus.

3. Pauze

De eerste optie die we uit een geneste lus moeten halen, is door simpelweg de breken uitspraak:

String resultaat = ""; for (int outerCounter = 0; outerCounter <2; outerCounter ++) {result + = "outer" + outerCounter; voor (int innerCounter = 0; innerCounter <2; innerCounter ++) {resultaat + = "inner" + innerCounter; if (innerCounter == 0) {pauze; }}} resultaat retourneren;

We hebben een buitenste lus en een binnenste lus, beide lussen hebben twee iteraties. Als de teller van de binnenste lus gelijk is aan 0, voeren we de breken opdracht. Als we het voorbeeld uitvoeren, zal het het volgende resultaat laten zien:

buiten0inner0outer1inner0

Of we kunnen de code aanpassen om deze wat beter leesbaar te maken:

buiten 0 binnen 0 buiten 1 binnen 0

Is dit wat we willen?

Bijna, de binnenste lus wordt beëindigd door de break-instructienadat 0 is gevonden. De buitenste lus gaat echter verder, dat is niet wat we willen. We willen de verwerking volledig stopzetten zodra we het antwoord hebben.

4. Gelabelde pauze

Het vorige voorbeeld was een stap in de goede richting, maar we moeten het een beetje verbeteren. We kunnen dat doen door een gelabeld pauze:

String resultaat = ""; myBreakLabel: for (int outerCounter = 0; outerCounter <2; outerCounter ++) {result + = "outer" + outerCounter; voor (int innerCounter = 0; innerCounter <2; innerCounter ++) {resultaat + = "inner" + innerCounter; if (innerCounter == 0) {breek myBreakLabel; }}} resultaat retourneren;

EEN gelabeld break beëindigt de buitenste lus in plaats van alleen de binnenste lus. Dat bereiken we door de myBreakLabel buiten de lus en het veranderen van de break-instructie om te stoppen myBreakLabel. Nadat we het voorbeeld hebben uitgevoerd, krijgen we het volgende resultaat:

buiten0inner0

We kunnen het wat beter lezen met wat opmaak:

buiten 0 binnen 0

Als we naar het resultaat kijken, kunnen we dat zien zowel de binnenste lus als de buitenste lus zijn beëindigd, dat is wat we wilden bereiken.

5. Terugkeren

Als alternatief kunnen we ook de terugkeer instructie om het resultaat direct te retourneren wanneer het is gevonden:

String resultaat = ""; for (int outerCounter = 0; outerCounter <2; outerCounter ++) {result + = "outer" + outerCounter; voor (int innerCounter = 0; innerCounter <2; innerCounter ++) {resultaat + = "inner" + innerCounter; if (innerCounter == 0) {resultaat retourneren; }}} retourneer "mislukt";

Het label wordt verwijderd en het breken statement wordt vervangen door een terugkeer uitspraak.

Als we de bovenstaande code uitvoeren, krijgen we hetzelfde resultaat als voor de gelabelde break. Merk op dat om deze strategie te laten werken, we meestal het blok met lussen naar zijn eigen methode moeten verplaatsen.

6. Conclusie

We hebben dus gekeken wat we moeten doen als we een lus vroegtijdig moeten verlaten, bijvoorbeeld wanneer we het item hebben gevonden waarnaar we op zoek zijn. De breken trefwoord is handig voor enkele lussen, en we kunnen gelabeld brekens voor geneste lussen.

Als alternatief kunnen we een terugkeer uitspraak. Door return te gebruiken, wordt de code beter leesbaar en minder foutgevoelig, omdat we niet hoeven na te denken over het verschil tussen ongelabelde en gelabelde pauzes.

Bekijk gerust de code op GitHub.