Hoofdstuk 7: Lussen
Inleiding
Een lus kan gebruikt worden om in een programma een aantal uitdrukkingen herhaaldelijk uit te voeren
- Stel dat je een stuk tekst (type
String) honderd keer moet op het scherm tonen. Of dat je een berekening moet doen die veel herhaling vergt. Dan zou je eenzelfde stukje code honderd keer moeten herhalen. Dat kan heel omslachtig zijn en vergroot de kans op fouten:
System.out.println("Welkom bij Java");
System.out.println("Welkom bij Java");
System.out.println("Welkom bij Java");
System.out.println("Welkom bij Java");
...
System.out.println("Welkom bij Java");
- Java heeft een heel belangrijke constructie die we een lus zullen noemen die controleert hoeveel keer een uitdrukking of een blok van uitdrukkingen wordt uitgevoerd. Het bovenstaande stuk code kunnen we ook schrijven met een dergelijke constructie:
int teler = 0;
while (teller < 100){
System.out.println("Welkom bij Java");
teller++;
}
Initieel is
tellereen variabel die de waarde 0 bevat. De lus controleert indienteller < 100, indien dit waar is dan worden de uitdrukkingen binnen de lus uitgevoerd. Indien de conditie niet waar is (false) dan wordt uit de lus gegaan en worden de uitdrukkingen uitgevoerd na de lus-structuur.Lussen zijn constructies die ons toelaten om herhaaldelijke uitvoeringen te controleren. In Java zijn er drie soorten lus structuren:
while-lussen,do-while-lussen enfor-lussen
De While lus
een
Whilelus voert uitdrukkingen uit zolang een voorwaarde waar is
- De syntax voor een
while-lus is als volgt:
while (lus-voorwaarde){
// body van de lus
Uitdrukking(en);
}
- Een lus kan ook voorgesteld worden als een flowchart:
- Het deel van de uitdrukkingen die moeten herhaald worden zullen de body van de lus noemen. Een eenmalige doorloop van de body noemen we iteratie (of herhaling).
- Elke lus heeft een
lus-voorwaarde. Dit is een Booleaanse uitdrukking dat de uitvoer van de body controleert. Als de voorwaardetrueis dan wordt de body uitgevoerd. Als de voorwaarde evalueert totfalse(niet waar) dan wordt de lus niet meer uitgevoerd en wordt overgegaan naar de eerstvolgende uitdrukking na de lus-structuur. Om via een while-lus 100 keer de tekst"Welkom bij Java"te tonen wordt dit:
int teler = 0;
while (teller < 100){
System.out.println("Welkom bij Java");
teller++;
}
- In dit voorbeeld weet je exact hoeveel de lus doorlopen moet worden en hoeveel iteraties de lus moet hebben. Dit soort lus is een teller-gecontroleerde lus.
- Een ander voorbeeld telt de eerste getallen op van 1 tot 9:
int som = 0, i = 1;
while (i < 10) {
som = som + i;
i++;
}
System.out.println("Som is " + som); //Som is 45
Als
i < 10waar is, zal het programma de waarde vanibijtellen bijsom. De waarde vaniis initieel geplaatst op 1, maar incrementeert na elke doorloop of iteratie van de lus. Wanneerigelijk wordt aan 10, is de lus-voorwaardei < 10niet waar, zodat de lus wordt doorbroken.Wat gebeurt als er per ongeluk een uitdrukking vergeten wordt zodat bovenstaand programma wordt:
int som = 0, i = 1;
while (i < 10) {
som = som + i;
}
System.out.println("Som is " + som); //Som is 45
- Deze lus is oneindig, want
iverandert niet dus de lus-voorwaardei < 10blijft altijdtrue. Let dus op dat je altijd ervoor zorgt dat de lus-voorwaardefalsewordt, zodat er geen oneindige lussen voorkomen.
Ontwerpstrategieën voor lussen
het voornaamste in het ontwerpen van lussen is het bepalen van het stukje code dat moet herhaald worden en een voorwaarde schrijven om de lus te beëindigen
- Het schrijven van een lus is geen eenvoudige taak voor beginnende programmeurs:
- Stap 1: bepaal de Java uitdrukkingen dat dienen herhaald te worden
- Stap 2: Schrijf deze in een lus als volgt:while (true) { Uitdrukkingen; }
- Stap 3 : Maak een lus-voorwaarde en voeg uitdrukkingen toe die de uitvoering van de lus controleren (e.g. een teller, of iets dat meetbaar is):
- while (lus-voorwaarde) { Uitdrukkingen; Bijkomende uitdrukkingen die de uitvoering van de lus controleren; }
De do-while lus
Een
do-whilelus is gelijkaardig aan dewhilelus, behalve dat de body van de lus één keer wordt uitgevoerd alvorens de lus-voorwaarde gecontroleerd wordt.
- De syntax van een
do-whilelus is
do {
// body van de lus;
Uitdrukkingen;
} while (lus-voorwaarde);
- De body van de lus wordt eerst uitgevoerd, daarna wordt de
lus-voorwaardegeëvalueerd. Als de evaluatie van delus-voorwaardetrueoplevert, dan wordt de body opnieuw uitgevoerd; als dezefalseoplevert, dan wordt de lus beëindigd. Voorgesteld door een flowchart wordt eendo-whilelus als volgt voorgesteld:
De for lus
- De syntax voor een
forlus is:
for (initiele-uitdrukking; lus-voorwaarde; actie-na-elke-iteratie) {
// Lus van de body
Uitdrukking(en);
}
- Een
forlus gebruikt een variabele om te controleren hoeveel keer een lus doorlopen moet worden. Deze variabele wordt de controlevariabele genoemd. Deinitiele-uitdrukkinginitializeert de controlevariabele en deactie-na-elke-iteratiezal de controlevariabele incrementeren of decrementeren. Delus-voorwaardetest indien de controlevariabele een waarde bereikt heeft om de lus te stoppen. - De flowchart van een for lus wordt voorgesteld als:
- Bovenstaand voorbeeld met een while-lus
int teler = 0;
while (teller < 100){
System.out.println("Welkom bij Java");
teller++;
}
kan gemakkelijk herschreven worden volgens een for-lus
for(int teller = 0; tellers < 100; teller++) {
System.out.println("Welkom bij Java");
}
- Een
forlus kan dus bondiger geschreven worden in vergelijking met eenwhilelus, omdat deze laatste veronderstelt dat een controlevariabele buiten de lus geïnitialiseerd wordt en dat in de body van de lus de controlevariabele geïncrementeerd of gedecrementeerd wordt.
Welke lus structuur te gebruiken?
- In elke situatie kan je elk van de lus structuren gebruiken.
- De
whilelus en dedo-whilelus zijn gemakkelijker te gebruiken dan deforlus. Eenforlus plaast de initializatie en de increment/decrement van de controlevariabele in de lus structuur, terwijl dewhileendo-whilelus deze buiten de lus worden gezet. - De
whileenforlus zullen eerst de lus-voorwaarde controleren alvorens de body uit te voeren. Ze worden daarom ook wel pretest lussen genoemd. Dedo-whilezal eerst een iteratie uitvoeren van de body en daarna de lus-voorwaarde controleren. Een dergelijke soort lus noemt men ook wel posttest lus. - De volgende herhaling kan je schrijven met een for en een while lus:
for-lus
//met een for-lus
for(int teller = 0; tellers < 100; teller++) {
System.out.println("Welkom bij Java");
}
//met een while-lus
int teller = 0;
while( tellers < 100) {
System.out.println("Welkom bij Java");
teller++;
}
- Een vuistregel is wanneer je weet hoeveel iteraties er moeten uitgevoerd worden, gebruik je een
for-lus. Als je het aantal iteraties niet op voorhand weet, omdat dit afhangt van een waarde van een variabele die kan veranderen tijdens de lus, dan gebruik je eerder eenwhileofdo-while.
Geneste lussen
Een lus kan binnen de body van een andere lus voorkomen. Dit zijn geneste lussen.
- Geneste lussen bestaan uit een buitenste lus en één of meerdere binnenste lussen. Bij elke herhaling van de buitenste lus, wordt de binnenste lus ook uitgevoerd.
- Bijvoorbeeld, onderstaand programma zal een vermenigvuldingstabel maken:
public class VermenigvuldigingsTabel{
/** Main methode **/
public static void main(String[] args){
//Toon de hoofding van de tabel
System.out.println(" Vermenigvuldingstabel");
//Toon de hoofding van de kolommen
System.out.print(" ");
for (int j = 1; j <= 9; j++){
system.out.print(" " + j);
}
System.out.println("\n------------------------------------");
//Toon de tabel
for(int i = 1; i <= 9; i++){ //buitenste lus
System.out.println(i + " | ");
for(int j = 1; j <= 9; j++){
//Toon het product en lijn mooi uit volgens een formaat
System.out.printf("%4d", i*j);
}
System.out.println();
}
}
}
Dit geeft:
Vermenigvuldingstabel
1 2 3 4 5 6 7 8 9
------------------------------------------------
1 | 1 2 3 4 5 6 7 8 9
2 | 2 4 6 8 10 12 14 16 18
3 | 3 6 9 12 15 18 21 24 27
4 | 4 8 12 16 20 24 28 32 36
5 | 5 10 15 20 25 30 35 40 45
6 | 6 12 18 24 30 36 42 48 54
7 | 7 14 21 28 35 42 49 56 63
8 | 8 16 24 32 40 48 56 64 72
9 | 9 18 27 36 45 54 63 72 81
- Let op: hou er rekening mee dat geneste lussen some lang kunnen duren. Beschouw volgend stuk code:
int som = 0;
for(int i = 0; i < 10000 ; i++){
for(int j = 0; j < 10000 ; j++){
for(int k = 0; k < 10000 ; k++){
som++;
}
}
}
- Ookal duurt de uitvoering van de body slechts een microseconde (), zal de volledige uitvoering meer dan 277 uren duren.