Wanneer u dezelfde actie meerdere keren wilt uitvoeren of totdat bepaalde toestand, hier komen cycli ons te hulp.

IN Java-taal Er zijn verschillende manieren om lussen te maken. Zoals je misschien al geraden hebt, zullen we ze allemaal overwegen.

De eerste manier om een ​​lus te declareren is door het volgende construct te gebruiken: for (startvoorwaarde van lus; eindvoorwaarde; stap waarop de lus zal gaan) (lichaam van lus)

Laten we meteen naar de voorbeelden gaan. Laten we zeggen dat we de taak hebben om de zinsnede “Hallo wereld” 10 keer weer te geven. Als je geen loops gebruikt, kun je gewoon System.out.println("Hallo wereld"); tien keer en we zullen het probleem oplossen. Laten we hiervoor lussen gebruiken. Creëren nieuwe klasse en noem het bijvoorbeeld CuclesInJava. Verklaar nu de lusvoorwaarde (laat deze 0 zijn), de eindvoorwaarde - 10 en de stap. We gaan in stappen van één. Plaats in de hoofdtekst van de lus de regel System.out.println("Hallo wereld");

Hier is een codevoorbeeld:

Het resultaat van deze code is 10 regels op rij met de zin "Hallo wereld!"

Hoe zit het met het schrijven van iets complexer. We hebben de basis al geleerd. Laten we ze gebruiken.

Laten we een eenvoudige applicatie schrijven die elke keer dat een stap + een variabele gelijk is aan 5 een waarschuwingsregel weergeeft. Ik ben erg slecht in verbeelding))

Laten we eerst een code schrijven die een variabele die vanuit de console wordt ingevoerd als invoer accepteert. In het vorige artikel gaf ik een voorbeeld van deze code en we spraken af ​​dat ik dan zou uitleggen hoe het werkt en waar het vandaan komt. En nu zullen we het gewoon gebruiken:

Vervolgens moet je een lus schrijven die begint bij nul en tot tien telt (zoals in het vorige voorbeeld). In het lichaam van de lus schrijven we voorwaardelijke operator, die zal controleren of deze variabele gelijk is aan 5 en zo ja, dan zullen we de regel "OK" uitvoeren. Dit is wat ik heb:

java.util.Scanner importeren;

openbare klasse CuclesInJava(

int variabele = scanner.nextInt(); //we zullen hier geleidelijk aan komen en dan zal duidelijk worden hoe het werkt

voor (int i = 1; ik< 10 ; i++ ) {

int nieuweVariabele = i + variabele;

if (nieuweVariabele==5) (

Het bleek niet heel ingewikkeld. Met dit voorbeeld wilde ik laten zien hoe je lussen met vertakkingen in combinatie kunt gebruiken.

De volgende manier om lussen te declareren is met de constructie: while(voorwaarde is waar)(uit te voeren codeblok). Dit ontwerp heeft een andere vorm:

do(uit te voeren codeblok)while(voorwaarde is waar). Het verschil tussen de eerste en de tweede is dat de tweede één lus uitvoert, ongeacht of de voorwaarde waar is of niet. Je kunt zelf bedenken: eerst voeren we de code uit, en dan controleren we de voorwaarde. En zelfs als de voorwaarde niet waar is, zal de code nog steeds één keer worden uitgevoerd, op het moment dat bij het eerste type constructie de voorwaarde voor het eerst wordt gecontroleerd, en totdat deze waar is, zal de code niet worden uitgevoerd.

De code moet intuïtief zijn. Ik denk dat het de moeite waard is om te vermelden dat je dat met de while- en do-while-constructies kunt doen "lus" programma als de voorwaarde voor het verlaten van de lus niet of onjuist is opgegeven. Kijk naar het bovenstaande voorbeeld en bedenk wat er zou zijn gebeurd als ik niet i—, maar i++ had geschreven; of in plaats van i>0, i<0. Моя программа никогда не вышла бы из цикла и продолжала бы выводить строку Hello world! до тех пор, пока не завис компьютер. Поэтому, будьте очень осторожными с циклами и всегда следите, чтобы из них Ваша программа могла выйти или закончить работу.

Nou, een voorbeeld met do-while:

Hierover kunnen we, denk ik, het artikel afmaken lussen in Java. Zoals je kunt zien, zijn de ontwerpen niet erg complex, maar wel erg nuttig. Ze zullen vooral nuttig zijn als we kennis maken met arrays en strings.

Java beschikt, net als bijna elke programmeertaal, over hulpmiddelen die ervoor zorgen dat een bepaald stukje code vele malen wordt herhaald, of loops, zoals ze gewoonlijk worden genoemd. Lussen in Java worden weergegeven door uitspraken zoals for en while, evenals hun variaties. Meestal worden lussen gebruikt om eendimensionale en multidimensionale arrays en itereerbare datastructuren (inclusief verzamelingen) te doorkruisen om bepaalde elementen te vinden en daarop verder te werken. Dit is echter niet de enige manier om een ​​tool als de Java-loop te gebruiken. Gebruiksvoorbeelden worden verstrekt zodra ze worden beoordeeld.

Java: beschrijving en voorbeelden

De fundamentele lusoperator in Java is while. Het codefragment dat in de hoofdtekst is ingesloten, wordt herhaald totdat de voorwaarde van de tussen haakjes geplaatste expressie voldoet aan de logische waarde van waarheid. De algemene vorm van de while-instructie is als volgt:

terwijl(voorwaarde) (

// luslichaam

Zodra de waarde van de logische voorwaarde niet langer waar is, stopt de uitvoering van de code in de hoofdtekst van de lus en wordt de controle overgedragen naar de regel die er onmiddellijk op volgt.

Als de hoofdtekst van de lus slechts één statement bevat, kunnen accolades worden weggelaten, maar het wordt als een goede vorm beschouwd als ze altijd aanwezig zijn. De figuur hierboven toont een blokdiagram van de werking van deze operator.

Laten we voor de duidelijkheid eens kijken naar het voorbeeld in de onderstaande afbeelding:

Het gedeclareerde aantal variabelen heeft aanvankelijk de waarde 1. Vervolgens zien we een logische expressie tussen haakjes achter de naam van de operator. Het zal waar zijn, d.w.z. retourneert true zolang de waarde van de count-variabele kleiner is dan of gelijk is aan 10. In de body van de lus wordt bij elke doorgang (iteratie) de waarde van de variabele met 1 verhoogd en weergegeven op het consolescherm. Merk op dat toen de variabele 11 bereikte, de lus stopte met draaien.

Als de waarde van de telvariabele aanvankelijk gelijk was aan 11, zou de lusvoorwaarde onwaar zijn en zou het programma niet eens in de hoofdtekst komen.

Het is vermeldenswaard dat u met de Java-syntaxis een while-instructie zonder hoofdtekst kunt gebruiken. Laten we een voorbeeld geven. Laten we zeggen dat we twee variabelen i = 100 en j = 200 hebben, we worden geconfronteerd met de taak om hun rekenkundig gemiddelde programmatisch te berekenen - hiervoor kunnen we de "holle" gebruiken terwijl:

terwijl(++i< --j);

Als gevolg hiervan zal de waarde van elk van de twee variabelen gelijk zijn aan het gemiddelde van hun oorspronkelijke waarden. Zoals je kunt zien, werkte de lus perfect zonder lichaam en voerde alle noodzakelijke acties uit in de voorwaardelijke expressie.

do-while-lus

Als in de voorgaande voorbeelden de voorwaardelijke expressie aanvankelijk false retourneerde, negeerde de programma-uitvoering de hoofdtekst van de lus en ging verder. Er doen zich echter vaak situaties voor waarin uitvoering van de code in de hoofdtekst van de lus minstens één keer vereist is, ongeacht de waarheid van de voorwaardelijke uitdrukking. Met andere woorden, het komt voor dat het controleren van de waarheid van een voorwaardelijke uitdrukking niet aan het begin, maar aan het einde van de lus vereist is. Een variatie op de while-lus genaamd do-while kan deze functionaliteit bieden. Het heeft de volgende vorm:

Doen(
// luslichaam

) terwijl(voorwaarde);

Zoals we kunnen zien, wordt eerst de hoofdtekst van de lus uitgevoerd, en pas daarna wordt de waarheid van de voorwaarde gecontroleerd - en zo bij elke iteratie.

De bovenstaande code werkt op vrijwel dezelfde manier als bij een gewone while. Als we echter het aantal op 11 zetten, wordt de hoofdtekst van de lus nog steeds één keer uitgevoerd voordat de instructie de waarheid van de expressie kan testen.

Beschrijving en voorbeelden van for - Java-lus

Vertegenwoordigt een universele en efficiënte taalvorm in Java. Vóór de vijfde versie van de Java SDK was er slechts één traditionele vorm van de for-operator, en daarna verscheen er een nieuwe - voor elke. In deze sectie zullen we kijken naar de traditionele vorm van de operator. voor Java ziet de lus er als volgt uit:

Voordat de besturing wordt overgedragen naar de code in de lusbody, wordt eerst de variabele i, die als teller fungeert, geïnitialiseerd. Vervolgens wordt een voorwaardelijke expressie gecontroleerd die de teller vergelijkt met een specifieke waarde, en als deze waar retourneert, wordt de hoofdtekst van de lus uitgevoerd. Vervolgens wordt de tellerwaarde gewijzigd met een vooraf bepaalde stap en wordt de voorwaardelijke uitdrukking opnieuw gecontroleerd, enzovoort totdat de voorwaarde onwaar wordt. Het onderstaande stroomschema illustreert alle fasen van de cyclus.

Voor een beter begrip is hier een voorbeeld van hoe een Java for-lus werkt:

We zien dat de variabele loopVal als teller wordt gebruikt. Na elke iteratie van de lus zal de waarde ervan met 1 toenemen, en dit zal doorgaan totdat deze 11 bereikt. Merk op dat een controlevariabele buiten een for-instructie kan worden gedeclareerd, maar als u niet van plan bent deze variabele ergens anders te gebruiken dan in een lus wordt aanbevolen om het rechtstreeks in de instructie te declareren. Houd er rekening mee dat een variabele die in de instructie zelf wordt gedeclareerd, een bereik heeft binnen dezelfde lus.

Er zijn situaties waarin u meerdere luscontrolevariabelen moet declareren. Voor Java kunt u met een lus twee of meer variabelen opgeven, gescheiden door komma's, en dit zowel tijdens de initialisatie als tijdens de iteratie. Zo'n operator ziet er als volgt uit:

for(int i = 1, int j = 10; ik< j; ++i, --j) {}

Bij elke iteratie zal de waarde van variabele i met 1 toenemen, en de waarde van variabele j met 1 afnemen. Er zullen iteraties worden uitgevoerd totdat i groter wordt dan of gelijk is aan j.

Functies van het gebruik van de for-operator

De for-lus is een redelijk flexibel ontwerp omdat alle drie de onderdelen ervan (initialisatie, voorwaarde en verhogen/verlagen) voor andere doeleinden kunnen worden gebruikt. In plaats van een voorwaardelijke expressie met een controlevariabele kunt u bijvoorbeeld elke logische variabele vervangen.

Booleaanse exit = false;

voor (int i = 0; !exit; ++i) (

In het bovenstaande voorbeeld kunnen we zien hoe de werking van de lus absoluut onafhankelijk is van de stuurvariabele i en dat het aantal iteraties uitsluitend afhangt van het moment waarop de uitgangsvariabele waar wordt. Bovendien kan de controlevariabele volledig uit de lus worden verwijderd en dit heeft geen enkele invloed op de werking ervan: for(; !exit;) (). Hoewel dit niet de slimste manier van programmeren is, kan het soms nuttig zijn. Het belangrijkste is om te zorgen voor een situatie waarin de variabele de waarde aanneemt die nodig is om de lus te verlaten, om er niet een oneindige van te maken.

Voor Java kan een lus ook op deze manier worden gedeclareerd: for(; ;) (). Dit is een typisch voorbeeld van een oneindige lus met speciale interruptvoorwaarden. We zullen later praten over hoe we dit soort cycli kunnen onderbreken.

Voor elke stijllus

De Java foreach-lus wordt altijd gebruikt om opeenvolgend door de elementen van een array of iets anders te itereren en bepaalde herhalende bewerkingen daarop uit te voeren. Een voorbeeld van deze vorm van de for-instructie wordt hieronder weergegeven:

Naam wordt gedeclareerd als een iteratieve variabele, en de eerder gedeclareerde reeks tekenreeksnamen fungeert als het tweede argument van de operator. De naamvariabele neemt beurtelings de waarden van elk array-element over totdat alle elementen ervan zijn opgehaald. Opgemerkt moet worden dat het type variabele compatibel moet zijn met het type elementen dat in de array is opgeslagen. Bovendien is de naamvariabele alleen-lezen en als u probeert deze te wijzigen, wordt het element in de array zelf niet gewijzigd.

Loop-interrupt-instructies

Er zijn drie lusonderbrekingsinstructies: break, return en continue. De eerste twee kunnen de lus volledig onderbreken, terwijl doorgaan alleen de huidige iteratie onderbreekt. Als u in uw code opzettelijk een oneindige lus in Java gebruikt, moeten deze operators daarin aanwezig zijn. Laten we eens kijken naar een eenvoudig voorbeeld van het gebruik van break:

Hoewel deze for-instructie 11 iteraties heeft, zullen er slechts 8 worden uitgevoerd, omdat wanneer de telling i gelijk is aan 7, de voorwaarde die de break-instructie bevat, wordt geactiveerd.

De return-instructie werkt op een vergelijkbare manier, met het verschil dat deze niet alleen een exit biedt uit de Java-lus, maar ook uit de methode waarin de lus is geplaatst.

Break gebruiken als goto

Houd er rekening mee dat een pauze alleen de lus onderbreekt in het lichaam waarvan deze zich direct bevindt, d.w.z. als je het in een geneste lus gebruikt, stopt de buitenste lus niet met lopen. Om dit te doen, kan de break-instructie worden gebruikt als een beschaafde vorm van goto.

In deze versie wordt deze operator gebruikt in combinatie met een label, waarmee u niet alleen een uitgang uit lussen kunt organiseren, maar ook uit elk codeblok. Een label is een toepasselijk benoemde identificatie, gevolgd door een dubbele punt. Het label wordt gedeclareerd aan het begin van het codeblok dat wordt gemarkeerd. Om de uitvoering van een gemarkeerd blok te onderbreken, moet u op de juiste plaats declareren: break label_name. Beschouw het voorbeeld in de onderstaande afbeelding:

De code declareert drie blokken met respectievelijk de labelnamen Eén, Twee en Drie. De break-instructie met de naam Two is in alle drie de blokken genest, maar wanneer deze wordt geactiveerd, verlaat het programma de blokken Drie en Twee en gaat de uitvoering voort in blok Eén. Die. in de console zien we twee berichten: Drie en Eén.

Conclusie

We leerden over het concept van lussen in Java, respectievelijk de belangrijkste while- en for-instructies, en hun do-while en for Each-vormen. Voor een beter begrip raden we aan om oefeningen te doen waarbij u deze operatoren in verschillende vormen gebruikt, evenals verschillende manieren om ze te onderbreken en van het ene blok naar het andere te gaan.

Een lus is een blok opdrachten dat keer op keer wordt uitgevoerd zolang aan een bepaalde voorwaarde wordt voldaan. Het herhaalde stukje code wordt de "loop body" genoemd. Eén uitvoering van de lusbody wordt een iteratie genoemd.

In Java kun je met verschillende soorten lussen werken - hiervoor zijn er de volgende operators:

terwijl– fietsen met voorwaarde– eerst controleren we de voorwaarde en voeren vervolgens de hoofdtekst van de lus uit;

doe... terwijl– fietsen met postconditie– eerst voeren we de hoofdtekst van de lus één keer uit, daarna controleren we de voorwaarde en als aan deze voorwaarde is voldaan, gaan we verder;

voor– lus met een teller – voert de teller uit en werkt deze bij elke iteratie bij, zolang aan de voorwaarde in de lusdeclaratie wordt voldaan (dat wil zeggen, het controleren van de voorwaarde retourneert waar);

afgekort voor(in andere talen bekend als foreach) – itereert de array van het eerste tot het laatste element en voert bij elke iteratie de hoofdtekst van de lus uit.

De essentie van de lusvoorwaarde is het controleren van een expressie met een of meer variabelen: “While a<11, в каждой итерации выполняем тело цикла и увеличиваем "а" на 1». Но чему равно «а» при первом выполнении цикла?

Als we constructies met while gebruiken, moet de waarde vóór het begin van de lus worden opgegeven:

int a = 1;

terwijl (een< 11) {

Systeem.out.println(a);

een++; //verhoog a met één

}

Als de variabele als lusteller werkt en niet daarbuiten wordt gebruikt, wordt deze rechtstreeks in de voorwaarde geïnitialiseerd. En dan schrijven ze aan het einde van elke iteratie wat ze ermee moeten doen. Dit alles - op één regel - gebruikend voor:

voor (a=1, een<11, i++) {

Systeem.out.println(a);

}

We krijgen hetzelfde resultaat. De lijst kan beginnen vanaf nul of vanaf een negatieve waarde; het bereik bepalen we zelf.

De verkorte versie van de for-lus bevat geen indicatie van het aantal herhalingen of acties aan het einde van de stap. Een foreach-lus wordt gebruikt om door arrays te itereren. U moet van het eerste element naar het volgende gaan totdat de array eindigt.

int ms = (1, 2, 3, 4); // maak een array

ints = 0;

for(int i: ms) ( //specificeer wat er herhaald moet worden

s *= ik; // vermenigvuldig de elementen consequent

}

Systeem.out.println(s);

Java-geneste lussen

Lussen kunnen in elkaar worden genest. In dit geval wordt het aantal herhalingen van de buitenste en geneste lussen vermenigvuldigd. Als de buitenste lus 5 keer moet worden uitgevoerd en de binnenste vijf keer, wordt de lus in totaal 25 keer uitgevoerd.

Laten we de tafel van vermenigvuldiging weergeven met behulp van twee arrays:

int a, b, resultaat = 0;

voor (a = 2; een< 10; a++) {

voor (b = 2; b< 10; b++) {

resultaat = a*b;

Systeem.out.println(a+"x"+b+" = "+resultaat);

}

}

Objecten maken in een Java-loop

Lussen zijn handig als u veel objecten moet maken en nummeren. Hun aantal is soms vooraf onbekend: objecten kunnen op verzoek van de gebruiker worden aangemaakt. Dus vroegen we hoeveel iets nodig was en schreven het getal in de variabele n. Laten we nu objecten in de vereiste hoeveelheid maken:

Iets array = nieuw Iets[n]; //maak een array van het type “iets” van n elementen

voor(int i = 0; ik< n; i++){

array[i] = nieuw Iets(); //maak “iets” en plaats het in een array

}

Hoe je uit een Java-lus kunt breken

Om een ​​lus te verlaten, zijn er de trefwoorden break - "interrupt", continue - "resume" en return - "return". Het break-commando zorgt ervoor dat het programma de instructies na de lus uitvoert. Voorwaarden voor lusonderbreking in Java worden geformaliseerd door middel van if-branching. Het belangrijkste is dat de controle wordt uitgevoerd vóór het hoofdgedeelte van het luslichaam.

//na het maken van array m schrijven we:

voor (een: m) (

als (a==5) breuk;

Systeem.out.println(a);

}

Branch- en lusoperatoren werken in Java vaak samen: we starten een lus en daarin controleren we of er nog niet aan een voorwaarde is voldaan waaronder we de lus moeten onderbreken of iets anders moeten doen.

Als u break in een geneste lus gebruikt, wordt alleen die lus onderbroken, terwijl de buitenste lus doorgaat met uitvoeren.

Om een ​​for-lus-iteratie vroeg in Java te beëindigen, wordt continue gebruikt. Wanneer het programma dit punt bereikt, slaat het het onvoltooide deel van de iteratie over, werkt de teller bij en gaat verder met de volgende iteratie.

In while-constructies werkt hetzelfde continue proces anders: het brengt ons terug naar het controleren van de voorwaarde voor het voortzetten van de lus. Een ander commando, return, retourneert het programma naar de plaats waar de methode waarin de lus zich bevindt, werd aangeroepen.

Zowel continue als break kunnen worden gebruikt met een label - om naar het gewenste deel van de code te springen - naar analogie met goto:

breakMark1; //op voorwaarde dat Mark1 ergens boven staat:

Java oneindige lus

Het maken van een oneindige lus is eenvoudig: geef alleen geen parameters op in de for:

voor (; ;) ()

Het is moeilijker om ervan te profiteren. Normaal gesproken is een oneindige lus een kritieke fout die verhindert dat het programma wordt uitgevoerd. Daarom moet elke lus worden gecontroleerd op zijn vermogen om correct op het juiste moment te eindigen. Om dit te doen heb je nodig:

• geef interruptcondities aan in de body van de lus,
• zorg ervoor dat de variabele in de interruptvoorwaarde een waarde kan aannemen waarbij de lus wordt gestopt.

Moet u veel van hetzelfde type gegevens verwerken? Wilt u een reeks berekenen? Moet je matrices vermenigvuldigen? Dit alles en nog veel meer zal u helpen de cyclus te voltooien! 🙂 Alle computersystemen zijn oorspronkelijk ontworpen om gegevensverwerking te vergemakkelijken. En het is zelfs onmogelijk om je voor te stellen dat je een grote hoeveelheid gegevens zou verwerken zonder lussen.

Over het algemeen worden lussen bij het programmeren meestal in drie groepen verdeeld. De eerste groep zijn cycli met een teller. Daarin wordt de body van de lus een bepaald aantal keren uitgevoerd, aanvankelijk gespecificeerd door de programmeur. Een dergelijke lus zal noodzakelijkerwijs een bepaald aantal keren worden uitgevoerd. De tweede groep zijn cycli met een voorwaarde. Daarin wordt de hoofdtekst van de lus pas uitgevoerd nadat een bepaalde voorwaarde is gecontroleerd, en wordt deze uitgevoerd zolang deze voorwaarde waar is. Dergelijke lussen mogen niet eens één keer worden uitgevoerd (als de voorwaarde aanvankelijk onwaar is). En de derde groep cycli zijn cycli met een postconditie. Daarin wordt eerst de body van de lus uitgevoerd en vervolgens wordt de voorwaarde gecontroleerd. Deze lus wordt minimaal één keer uitgevoerd.

Laten we beginnen met een lus met een teller. In Java is dit een for-lus; Over het algemeen kan het als volgt worden geschreven:

For (Startvoorwaarde; eindvoorwaarde; verandering) ( luslichaam; )

Dus als we een actie 10 keer willen uitvoeren, moeten we het volgende schrijven:

Voor (int i = 0; ik<10; i++) { System.out.println(i); }

zo'n programma zal opeenvolgend getallen van nul tot negen weergeven. Iets gedetailleerder: we creëren eenvoudigweg een nieuwe variabele i en kennen deze de initiële waarde 0 toe (int i = 0;). Vervolgens specificeren we dat de lus moet worden uitgevoerd tot i< 10 и указываем каким образом должно изменяться i после каждой итерации цикла (i++).

Degenen die in Pascal hebben geprogrammeerd zullen blij zijn met deze mogelijkheid:

Intk = 15;

voor (zweven i = 0; i

In dit voorbeeld zal de waarde van de variabele i bij elke iteratie met 1,5 toenemen. Je kunt het bekijken :). terwijl Volgende cyclus in lijn -

. Dit is een lus met een voorwaarde en in algemene vorm kan deze als volgt worden geschreven:

Terwijl(logische expressie) ( acties )

Als we een werkend voorbeeld nemen, ziet het er ongeveer zo uit:<10) { System.Out.Print(a); a++; }

Terwijl (een Het is dus duidelijk dat deze lus zinvol is om te gebruiken als je niet precies weet hoeveel iteraties nodig zijn om het doel te bereiken, maar je wel precies weet onder welke voorwaarde je doel zal worden bereikt. Zo'n constructie mag niet één keer worden uitgevoerd (het is immers een lus met een voorwaarde)! Hoe vaak de acties in de lus worden uitgevoerd, hangt af van de waarde die aanvankelijk in de variabele stond.

A En het derde type cycli zijn cycli met een postconditie. Hij lijkt erg op terwijl... doen En het derde type cycli zijn cycli met een postconditie. Hij lijkt erg op de voorwaarde wordt gecontroleerd voordat de hoofdtekst van de lus wordt uitgevoerd, hier wordt de voorwaarde gecontroleerd nadat de hoofdtekst van de lus is uitgevoerd. Dit betekent dat de lus minimaal één keer wordt uitgevoerd voordat de voorwaarde wordt gecontroleerd.

08/12/17 1,9K

Een Java While Do-lus is een statement waarmee u hetzelfde stukje code meerdere keren kunt uitvoeren. Deze lus kan worden gebruikt om acties te herhalen wanneer aan de voorwaarden wordt voldaan.

Terwijl lus

De while-lus is het eenvoudigst te construeren in de Java-taal. Het bestaat uit een while-sleutel, een lusvoorwaarde en een luslichaam:

while (voorwaarde) ( // luslichaam )

Elke afzonderlijke run van de lusbody wordt als een iteratie beschouwd. Vóór elke iteratie worden de lusvoorwaarden geëvalueerd. De body ervan wordt alleen uitgevoerd als de lusvoorwaarde resulteert in true .

De iteraties van de lus veranderen iets, en op een gegeven moment retourneert de conditie-evaluatie false , op welk punt de lus eindigt. Een lus waarvan de voorwaarde nooit false retourneert, wordt een oneindig aantal keren uitgevoerd. Dergelijke cycli worden eindeloos genoemd.

Voorbeeld

int aantal = 0; terwijl (num< 10) { System.out.println(num); num++; }

In dit voorbeeld worden de cijfers 0 tot en met 9 afgedrukt. Laten we de code stap voor stap doornemen. Eerst initialiseren we de num-variabele met de waarde 0. Dit wordt de lusteller. Wanneer het programma while bereikt, worden de voorwaarden van de lus geëvalueerd. In ons geval 0< 10 возвращает значение true и исполняется тело цикла. Внутри цикла выводится переменная num , а затем увеличивается на 1 . На этом завершается первая итерация.

Na de eerste "run" wordt de Java While-lusvoorwaarde een tweede keer geëvalueerd. 1< 10 по-прежнему возвращает true , после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз.

De laatste iteratie begint wanneer de waarde van num gelijk is aan 9 . De lusteller wordt nog een laatste keer weergegeven en de waarde wordt verhoogd naar 10. Deze keer kan er geen nieuwe iteratie worden gestart omdat de lusvoorwaarde false oplevert. Omdat 10 niet minder is dan 10.

De lus loopt dus door zolang aan de lusvoorwaarde wordt voldaan. Gewapend met deze kennis kun je complexere en functionelere loops creëren. Laten we de array doorlopen:

String namen = ("Doc", "Dopey", "Verlegen", "Chagrijnig", "Sneezy", "Sleepy", "Blij"); int-index = 0; terwijl (index< names.length) { System.out.println(names); index++; }

Het concept van dit voorbeeld is vergelijkbaar met het vorige. We initialiseren de lusteller en doorlopen de array totdat alle elementen zijn afgedrukt. Als gevolg hiervan is het herhalen van arrays een vrij algemeen geval, en Java heeft hiervoor een betere constructie: de For-lus.

do-while-lus

De Java while do-lus is vergelijkbaar met while , maar heeft een significant verschil: in tegenstelling tot while wordt de voorwaarde aan het einde van elke iteratie gecontroleerd. Dit betekent dat de do-while-lus altijd minimaal één keer wordt uitgevoerd:

do ( // loop body ) while (voorwaarde);

Voorbeeld

do-while voert eerst de hoofdtekst van de lus uit en evalueert vervolgens de voorwaarden ervan. Afhankelijk van het verkregen resultaat stopt de lus of begint de volgende iteratie. Laten we eens kijken naar een eenvoudig spel "raad de naam":

Scannerscanner = nieuwe scanner (System.in); Tekenreeks raden; do ( System.out.print("Raad de naam: "); raad = scanner.nextLine(); ) while (!"Daffy Duck".equals(raad)); System.out.println("Gefeliciteerd! Je raadt mijn naam!");

Dit terwijl Java bijvoorbeeld Scanner gebruikt om invoer van system.ini te parseren. Dit is in de meeste gevallen het standaardinvoerkanaal dat met het toetsenbord communiceert. Simpel gezegd lezen we simpelweg de tekst die de speler invoert.

In het spel moet je dit minimaal één keer aan de gebruiker vragen, en dit zolang de speler de juiste antwoorden invoert. De do-while-lus is ideaal voor dergelijke gevallen. In de hoofdtekst van de lus krijgen we de gebruikerswaarde en controleren vervolgens de juistheid van het antwoord. De lus moet worden uitgevoerd totdat de invoerwaarde van de gebruiker gelijk is aan Daffy Duck. Als het juiste antwoord wordt ontvangen, stopt de lus en feliciteren we de speler met zijn overwinning.

Tot slot

Met Java's while true loops kun je stukjes code meerdere keren hergebruiken. Vandaag maakten we kennis met Java while- en do-while-loops. Ze zijn vergelijkbaar in die zin dat ze de voorwaarden controleren en de hoofdtekst van de lus uitvoeren als de voorwaarde true oplevert. Maar tegelijkertijd hebben ze een significant verschil: de toestand van de while-lus wordt vóór de iteratie gecontroleerd, en de toestand van de do-while-lus wordt aan het einde van elke iteratie gecontroleerd. Dit betekent dat de do-while-lus altijd minimaal één keer wordt uitgevoerd.

Deze publicatie is een vertaling van het artikel “ Java's While- en Do-While-loops in vijf minuten", opgesteld door het vriendelijke projectteam