Oneindig voor (Java) lus

In Java, zoals in bijna elke programmeertaal, zijn er tools om de herhaling van een bepaald stuk code te waarborgen, of, zoals ze worden genoemd, cycli. Cycli in Java worden vertegenwoordigd door exploitanten zoals voor en terwijl, evenals hun rassen. In de regel worden cycli gebruikt om door middel van eendimensionale en multidimensionale arrays en iterated datastructuren (inclusief verzamelingen) door te gaan om bepaalde elementen en verdere operaties met hen te vinden. Dit is echter niet de enige manier om een gereedschap zoals de Java-lus te gebruiken. Voorbeelden van gebruik zullen worden gegeven als ze worden overwogen.

Cyclus tijdens Java: beschrijving en voorbeelden

De onderliggende cyclusverklaring in Java is onder. Het codefragment dat in zijn lichaam wordt ingesloten, wordt herhaald tot de conditie van de uitdrukking die tussen haakjes wordt omschreven, nadat het de logische waarde van de waarheid zal bevredigen. De algemene vorm van de tussentijdse verklaring is:

Terwijl (voorwaarde) {

// lichaam van de lus

}

Zodra de waarde van de logische toestand ophoudt, blijft de code in het lichaam van de lus ophouden en wordt de controle overgedragen aan de onmiddellijke volgende regel. Als er slechts één operator in het lichaam van de cyclus is, kunnen de beugels niet worden ingesteld, maar wordt het als een goede vorm beschouwd als ze altijd staan. De bovenstaande figuur toont een blokschema van de werking van deze operator.

Voor de duidelijkheid, laten we eens kijken naar het voorbeeld dat in onderstaande figuur wordt getoond:

De aangegeven variabele telling heeft aanvankelijk een waarde van 1. Vervolgens zien we een logische uitdrukking tussen haakjes achter de naam van de operator. Het zal waar zijn, ik. Ga terug tot de waarde van de tellervariabele kleiner is dan of gelijk is aan 10. In het lus van de lus wordt bij elke herhaling de waarde van de variabele verhoogd met 1 en op het consolescherm weergegeven. Merk op dat wanneer de waarde van de variabele 11 is bereikt, de cyclus stopte met werken.

Als de waarde van de variabele telling aanvankelijk gelijk was aan 11, dan zou de lusvoorwaarde vals zijn en het programma zou zelfs niet in zijn lichaam gaan.

Het is opmerkelijk dat de Java-syntax u toelaat om de ononderbroken verklaring zonder lichaam te gebruiken. Laten we een voorbeeld geven. Stel dat we twee variabelen hebben i = 100 en j = 200. We hebben de taak om hun rekenkundig gemiddelde te programmeren. U kunt de 'holle' gebruiken als:

Terwijl (++ i <- j);

Als gevolg hiervan is de waarde van een van de twee variabelen gelijk aan het gemiddelde van hun oorspronkelijke waarden. Zoals u kunt zien, werkt de cyclus perfect zonder een lichaam en voert u alle nodige acties uit in een conditional expressie.

Do-while loop

In de vorige voorbeelden, als de voorwaardelijke expressie aanvankelijk onwaar was, dan zou de uitvoering van het programma het lichaam van de lus negeren en verder gaan. Er zijn echter vaak situaties waarin de uitvoering van de code in het lichaam van de lus noodzakelijk is, minstens één keer, ongeacht de geldigheid van de voorwaardelijke expressie. Met andere woorden, het kan gebeuren dat het valideren van de geldigheid van een voorwaardelijke uitdrukking niet aan het begin, maar aan het einde van de cyclus vereist is. Deze functionaliteit kan worden geleverd door een soort, terwijl de lus genaamd do-while wordt genoemd. Het heeft het volgende formulier:

Doe {
// lichaam van de lus

} Terwijl (voorwaarde);

Zoals we kunnen zien, wordt het luslichaam eerst uitgevoerd, en pas dan wordt de waarheid van de conditie gecontroleerd - en dus bij elke iteratie.

De bovenstaande code werkt op dezelfde manier als bij de gebruikelijke tijd. Echter, als we de tellingvariabele een waarde van 11 geven, zou het luslichaam nog een keer worden uitgevoerd voordat de operator de validiteit van de expressie kon verifiëren.

Beschrijving en voorbeelden voor - Java cyclus

De voorloper is 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 voorverklaring, en dan een nieuw voor elk. In deze sectie zullen we kennis maken met de traditionele vorm van de operator. Voor Java ziet de lus als volgt uit:

Voordat de controle wordt doorgegeven aan de code in het lichaam van de lus, wordt de initialisatie van de variabele die ik gebruikt als de teller eerst uitgevoerd. Vervolgens kijken we naar de voorwaardelijke expressie, waarin de teller wordt vergeleken met een bepaalde waarde, en als het waar is, wordt het luslichaam uitgevoerd. Vervolgens wordt de tellerwaarde veranderd in een vooraf bepaalde stap en wordt de conditional expression opnieuw gecontroleerd, enzovoort totdat de toestand onwaar is. Het stroomdiagram hieronder illustreert alle fasen van de cyclus.

Voor een beter begrip, laten we een voorbeeld geven van hoe de Java-loop werkt:

We zien dat de loopVal-variabele wordt gebruikt als teller. Na elke iteratie van de lus zal de waarde met 1 stijgen en dit zal plaatsvinden tot het 11 bereikt. Let erop dat de besturingsvariabele ook buiten de voorstelling kan worden aangegeven, maar als u deze variabele niet meer wilt gebruiken behalve behalve In een lus, wordt het aanbevolen om het rechtstreeks in de verklaring te verklaren. Houd er rekening mee dat de aangegeven variabele in de verklaring zelf een reikwijdte heeft binnen dezelfde lus.

Er zijn situaties waarin u meerdere loopregelvariabelen wilt verklaren. Voor Java kan een lus twee of meer variabelen opgeven die gescheiden zijn door een komma, en dit doen tijdens initialisatie en tijdens iteratie. Een dergelijke exploitant heeft het volgende formulier:

Voor (inti = 1, int j = 10; i

Bij elke iteratie zal de waarde van ik met 1 toenemen en de waarde van j zal afnemen met 1. De iteraties worden uitgevoerd tot ik groter wordt dan of gelijk aan j.

Kenmerken van het gebruik van de voorverklaring

De voorloop is een vrij flexibele constructie, aangezien alle drie de onderdelen ervan (initialisatie, conditie en verhoging / afname) niet kunnen worden gebruikt voor het beoogde doel. Bijvoorbeeld, in plaats van een voorwaardelijke expressie met een regelvariabele, kunt u elke logische variabele vervangen.

Boolean exit = false;

Voor (int i = 0; Exit; ++ i) {

Exit = true;

}

In het bovenstaande voorbeeld kunnen we observeren hoe de werking van de lus absoluut onafhankelijk is van de regelvariabele i en het aantal iteraties hangt alleen af wanneer de uitgangsvariabele waar is. Bovendien kan de besturingsvariabele volledig van de lus worden verwijderd en dit heeft geen invloed op de werking ervan: voor (;! Exit;) {}. Hoewel dit niet de meest redelijke manier van programmeren is, kan het soms nuttig zijn. Het belangrijkste is om een situatie te verschaffen waarin de variabele de waarde zal nemen die nodig is om de lus te verlaten, om het niet te veranderen in een oneindige waarde.

Voor Java kan een lus op deze manier worden verklaard: voor (;;) {}. Dit is een typisch voorbeeld van een oneindige lus met speciale onderbrekingsomstandigheden. Over hoe we dit soort cycli kunnen onderbreken, we praten een beetje later.

Cyclus in stijl voor elk

De foreach-Java-lus wordt altijd gebruikt om sequentieel door middel van elementen van een array of een gegevenstructuur te zoeken en bepaalde herhaalde operaties op te voeren. Een voorbeeld van deze vorm van de voorverklaring is hieronder weergegeven:

Als een iteratieve variabele wordt de naam aangegeven, en de eerder aangegeven reeks namen is het tweede argument van de operator. De variabele naam zal de waarden van elk element van de array een tegelijk nemen totdat alle elementen ervan worden geëxtraheerd. Opgemerkt moet worden dat het type van de variabele compatibel moet zijn met het type elementen die in de array zijn opgeslagen. Ook is de naamvariabele alleen-lezen en probeert het te veranderen, het element zelf niet in het array veranderen.

Cycle Interrupt Operators

Er zijn drie interrupt statements voor de lus: breek, terug en ga verder. De eerste twee kunnen de lus volledig onderbreken, en doorbreken alleen de werking van de huidige iteratie. Als u een opzettelijk oneindige Java-cyclus in uw code gebruikt, moeten deze operators aanwezig zijn. Overweeg een simpel voorbeeld van het gebruik van pauze:

Alhoewel er 11 iteraties in dit voor de verklaring worden verstrekt, worden slechts 8 uitgevoerd, omdat wanneer de teller i 7 is, de toestand in het lichaam waarvan er een breukverklaring is, zal werken.

De retourverklaring werkt op een soortgelijke manier, met het verschil dat het niet alleen een uitgang geeft van de Java-lus, maar ook van de methode waarin deze lus wordt geplaatst.

Gebruik pauze als goto

Men moet er rekening mee houden dat de onderbreking het werk van alleen de cyclus in het lichaam waarvan het direct zich bevindt, d.w.z. Als u het in een geneste lus gebruikt, zal de buitenste lus niet stoppen met werken. Hiervoor kan de pauze verklaring als beschaafde vorm van goto worden gebruikt.

In deze variant wordt deze operator gebruikt in combinatie met het label, waarmee u de output niet alleen vanuit de cycli kunt organiseren, maar ook uit een blok van code. Een label is een aangewezen identificatiecode met een colon daarna. Het label wordt aan het begin van het gemarkeerde blok code aangegeven. Om de uitvoering van een gemarkeerd blok op de juiste plaats te onderbreken, moet u de volgende naam opgeven: naamnaam breken. Overweeg het voorbeeld in de figuur hieronder:

De code verklaart drie blokken met respectievelijk de namen van de etiketten Één, Twee en Drie. De pauze verklaring met het label Two is genesteld in alle drie blokken, maar wanneer het wordt geactiveerd, zal het programma de drie en twee blokken verlaten en de uitvoering in het One-blok verder gaan. ie In de console zullen we twee berichten zien: Drie en Één.

conclusie

We hebben geleerd over het concept van loops in Java, de belangrijkste tijd en voor uitspraken, respectievelijk hun do-while en voor elke vorm. Voor beter begrip adviseren wij u de oefeningen te gebruiken met behulp van deze operatoren in verschillende vormen, evenals verschillende manieren om ze te onderbreken en van het ene blok naar het andere te verhuizen.