Voorwaarden en lussen in Java

Een voorwaarde heeft het type boolean: die levert true of false op. Java heeft dat expliciete resultaat nodig in een if- of lusvoorwaarde. Een geheel getal op zichzelf is geen voorwaarde, dus while (count) compileert niet; count > 0 stelt een duidelijke vraag die waar of onwaar is.

Vergelijk getallen en tekens

Met int a = 7; en int b = 10; zijn a < b en a != b true, terwijl a >= b false is. Verschillende numerieke typen kun je vergelijken: 3 == 3.0 is true nadat Java het gehele getal via een verbredende typeconversie omzet naar een double.

Een vergelijking van char-waarden gebruikt Unicode-codenummers. Zo is 'a' < 'b' true. Dat geldt ook voor 'Z' < 'a': hun codes zijn 90 en 97. Alle ASCII-hoofdletters van A tot en met Z gaan in deze volgorde vooraf aan de kleine letters van a tot en met z.

Sla een bruikbaar antwoord op

int age = 17;
boolean isAdult = age >= 18;
System.out.println(isAdult);

De vergelijking geeft false, dat wordt opgeslagen in isAdult en daarna wordt afgedrukt. Dankzij een betekenisvolle naam kan latere code direct if (isAdult) gebruiken.

Houd toewijzing en vergelijking uit elkaar. = slaat een waarde op; == vergelijkt waarden. Voor een geheel getal werkt if (x = 5) niet, omdat de toewijzing een geheel getal oplevert. Voor een booleaanse waarde compileert if (done = true), zet de instructie done op true en wordt de tak uitgevoerd. Om de bestaande vlag te testen, schrijf je if (done).

Vergelijk tekst en berekende kommagetallen

Gebruik command.equals("quit") om de tekens van een string te vergelijken. Tekst die als “quit” is ingevoerd, komt overeen; “Quit” niet. Gebruik equalsIgnoreCase als het onderscheid tussen hoofdletters en kleine letters niet belangrijk is, en !command.equals("quit") om op verschillende tekst te testen. De operator == controleert of strings naar hetzelfde object verwijzen en is daarom niet geschikt om de inhoud van gebruikersinvoer te vergelijken.

Binaire zwevendekommagetallen kunnen veel decimale breuken niet exact opslaan. 0.1 + 0.2 levert 0.30000000000000004 op, dus 0.1 + 0.2 == 0.3 is false. Een vergelijking met een tolerantie controleert hoe ver de berekende waarden uit elkaar liggen:

double sum = 0.1 + 0.2;
boolean closeEnough = Math.abs(sum - 0.3) < 1e-9;

Hier maakt Math.abs het verschil niet-negatief; het kleine verschil ligt onder 1e-9, dus closeEnough is true. Kies een tolerantie die past bij de vereiste precisie van de berekening. Exacte vergelijkingen van int-waarden hebben geen afrondingsprobleem door zwevendekommagetallen.

Test deelbaarheid en bereiken

n % 3 == 0 test of een geheel getal deelbaar is door 3. Gebruik voor oneven getallen n % 2 != 0: die test omvat ook negatieve oneven waarden, omdat -7 % 2 gelijk is aan -1.

Schrijf elke kant van een bereiktest afzonderlijk: 0 < x && x < 10. Java kan 0 < x < 10 niet lezen als een wiskundige keten: de eerste vergelijking levert al een booleaanse waarde op, die niet met 10 kan worden vergeleken.

Logische operatoren combineren volledige voorwaarden die waar of onwaar zijn. Lees een gecombineerde voorwaarde als een regel over de gegevens en test daarna waarden die wel en niet aan de regel zouden moeten voldoen.

Verbind en ontken tests

&& betekent EN: beide delen moeten waar zijn. || betekent OF: minstens één deel moet waar zijn, ook als beide dat zijn. ! betekent NIET en keert één booleaanse waarde om.

| p | q | p && q | p || q | | --- | --- | --- | --- | | true | true | true | true | | true | false | false | true | | false | true | false | true | | false | false | false | false |

Voor een comfortabele temperatuur van 18 tot en met 24 °C zijn beide grenzen nodig: temp >= 18 && temp <= 24. Buiten dat interval betekent temp < 18 || temp > 24. Als je de binnengrenzen met || verbindt, wordt elk getal geaccepteerd: onder 18 is de test voor de bovengrens waar en boven 24 is de test voor de ondergrens waar.

Elke operand moet een booleaanse expressie zijn. Schrijf x == 1 || x == 2, omdat x == 1 || 2 een geheel getal plaatst waar een booleaanse waarde nodig is. Voor een geheel getal is !x > 5 ongeldig; !(x > 5) ontkent de hele vergelijking.

Evalueer alleen wat nodig is

Java evalueert && en || van links naar rechts en gebruikt kortsluitevaluatie als het linkerdeel de uitkomst bepaalt. Bij && wordt de rechterkant overgeslagen als de linkerkant onwaar is. Bij || gebeurt dat als de linkerkant waar is.

int total = 36;
int count = 0;
boolean largeAverage = count != 0 && total / count > 10;

De eerste vergelijking is onwaar, dus de deling wordt overgeslagen en largeAverage wordt false. Draai je de operanden om, dan vindt de deling vóór de beveiligende voorwaarde plaats; geheeltallige deling door nul werpt een ArithmeticException op. Zet de veiligheidscontrole vóór de berekening die die controle beschermt.

Maak de groepering zichtbaar

Van hoogste naar laagste prioriteit zijn de relevante operatoren !, ordevergelijkingen (<, <=, >, >=), gelijkheidsvergelijkingen (==, !=), && en dan ||. Dus a || b && c wordt gegroepeerd als a || (b && c). Als a waar is en b en c onwaar zijn, is die expressie waar; (a || b) && c is onwaar. Met haakjes laat je zien welke regel je bedoelt.

De wetten van De Morgan verplaatsen een negatie over een gecombineerde voorwaarde:

• !(p && q) is gelijk aan !p || !q.
• !(p || q) is gelijk aan !p && !q.

Ontken elk deel en verwissel de verbindende operator. Toegepast op het temperatuurbereik is !(temp >= 18 && temp <= 24) gelijk aan temp < 18 || temp > 24.

Druk een regel met een uitzondering uit

Een gregoriaans schrikkeljaar is deelbaar door 4, behalve dat een eeuwjaar deelbaar moet zijn door 400:

boolean leap = (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;

Het eerste deel accepteert 2024. Het verwerpt 1900 omdat 1900 een eeuwjaar is; de laatste test accepteert 2000 omdat dat deelbaar is door 400. Het jaar 2026 voldoet aan geen van beide delen.

Booleaanse variabelen met een naam maken langere tests duidelijk leesbaar, zoals isWeekend || isHoliday. Voor twee booleaanse waarden is ^ exclusieve OF: precies één operand moet waar zijn, net als bij !=. De enkele & en | berekenen ook logische EN en OF op booleaanse waarden, maar evalueren beide operanden; gebruik && en || voor voorwaarden met kortsluitevaluatie.

Een if voert een blok uit als de voorwaarde waar is. Een if met een else kiest precies één van twee blokken. Nadat het gekozen blok is afgerond, gaat de uitvoering verder met de volgende instructie.

Kies een pad

int age = 16;
if (age >= 18) {
    System.out.println("Adult ticket");
} else {
    System.out.println("Youth ticket");
}
System.out.println("Next customer");

De voorwaarde is onwaar, dus de uitvoer is “Youth ticket”, gevolgd door “Next customer”. De laatste instructie hoort bij geen van beide takken. Zet de booleaanse voorwaarde tussen haakjes en de instructies van elke tak tussen accolades.

Zonder accolades hoort alleen de volgende instructie bij een if. Inspringing groepeert geen code. In dit foutieve voorbeeld verschijnt het tweede bericht voor elke score:

if (score < 50)
    System.out.println("Not passed");
    System.out.println("Try again");

Met accolades rond beide afdrukinstructies worden beide voorwaardelijk uitgevoerd. Een andere fout is een puntkomma direct na de voorwaarde: if (x > 10); heeft een lege body. Een blok dat erop volgt, wordt onafhankelijk uitgevoerd en een else na dat onafhankelijke blok heeft geen bijpassende if.

Houd een resultaat beschikbaar

Een variabele die binnen een blok is gedeclareerd, is alleen binnen dat blok zichtbaar. Declareer een resultaat vóór de takken als latere code het nodig heeft:

String ticket;
if (age >= 18) {
    ticket = "Adult ticket";
} else {
    ticket = "Youth ticket";
}
System.out.println(ticket);

Beide mogelijke paden wijzen een waarde toe aan ticket, dus die daarna afdrukken is geldig. Als alleen de tak voor waar een waarde zou toewijzen, zou Java het latere lezen afwijzen: de variabele is mogelijk niet geïnitialiseerd. Als je ticket afzonderlijk binnen elke tak zou declareren, zou er na de beslissing ook geen ticket beschikbaar zijn.

Plaats een beslissing binnen een andere

Een geneste if voert de test alleen uit als de uitvoering de omringende tak bereikt:

if (hasTicket) {
    if (age < 12) {
        System.out.println("Child seat");
    } else {
        System.out.println("Standard seat");
    }
} else {
    System.out.println("Buy a ticket first");
}

Iemand zonder kaartje bereikt de buitenste else; de leeftijdscontrole wordt overgeslagen. Als beide geneste tests alleen dezelfde actie bewaken en geen van beide een else heeft, kun je ze samenvoegen tot if (hasTicket && age < 12).

De regel voor de losse else koppelt een else aan de dichtstbijzijnde if zonder bijbehorende else. Zonder accolades verandert het visueel uitlijnen met een buitenste if die regel niet. Bij een buitenste test of x positief is, gevolgd door een binnenste test of y positief is, hoort de volgende else bij de test van y. Als de else bij de buitenste test moet horen, zijn accolades rond de volledige binnenste beslissing nodig.

Kies een waarde met ?:

De conditionele operator kiest één van twee waarden:

int n = 7;
String label = n % 2 == 0 ? "even" : "odd";

De voorwaarde is onwaar, dus de expressie geeft “odd”. De vorm is condition ? valueIfTrue : valueIfFalse. Gebruik de operator om kort een waarde te kiezen; gebruik een if als takken meerdere acties uitvoeren. Geneste conditionele expressies maken het gekozen pad al snel moeilijk te volgen.

Een else if-keten test voorwaarden op volgorde en kiest de eerste die waar is. Zodra die tak wordt uitgevoerd, worden de overige voorwaarden overgeslagen. Een laatste else handelt de overgebleven waarden af; zonder die laatste tak kan het gebeuren dat de keten geen actie uitvoert.

Orden overlappende drempelwaarden

Test voor scores van 0 tot 100 eerst de hoogste beoordeling:

String grade;
if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else if (score >= 60) {
    grade = "D";
} else {
    grade = "F";
}

Bij 85 faalt de eerste test en slaagt de tweede. Het programma wijst “B” toe zonder de overige drempelwaarden te controleren. Als score >= 80 wordt bereikt, betekent dit al dat de score onder 90 ligt, dus een extra bovengrens is niet nodig.

Als score >= 60 eerst zou staan, zou elke voldoende score “D” krijgen. Werk van het meest beperkende passende geval naar de ruimere gevallen. Deze volgorderegel is van belang omdat meerdere voorwaarden waar kunnen zijn, ook al wordt slechts één tak uitgevoerd.

Handel het gecombineerde geval eerst af

FizzBuzz heeft een speciaal geval waarin twee regels overlappen: veelvouden van zowel 3 als 5 hebben “FizzBuzz” nodig. Test dat geval vóór de afzonderlijke deelbaarheidstests:

if (n % 15 == 0) {
    System.out.println("FizzBuzz");
} else if (n % 3 == 0) {
    System.out.println("Fizz");
} else if (n % 5 == 0) {
    System.out.println("Buzz");
} else {
    System.out.println(n);
}

De test % 15 == 0 accepteert 30; 9 bereikt “Fizz”, 10 bereikt “Buzz” en 7 bereikt de laatste tak. Beginnen met % 3 == 0 zou 30 te vroeg accepteren en alleen “Fizz” afdrukken.

Kies één uitkomst of meerdere acties

Afzonderlijke if-instructies zijn onafhankelijke beslissingen. Met x = 15 kan een if (x > 10) “big” afdrukken en een daaropvolgende if (x > 0) ook “positive”. Als je ze met else if verbindt, is de tweede test onbereikbaar wanneer de eerste waar is. Gebruik onafhankelijke tests als beide acties nodig kunnen zijn; gebruik een keten voor één gekozen uitkomst.

Controleer grenswaarden en ongeldige waarden

Een keten voor gehele temperaturen met temp < 10, dan temp > 10 && temp < 25, dan temp >= 25 mist precies 10. Vervang de tweede test door temp < 25: als die wordt bereikt, betekent dit al dat de eerste test is mislukt, dus de waarde is minstens 10. Een laatste else handelt dan 25 en hoger af.

Probeer voor elke grens de waarde er vlak onder, de grens zelf en de waarde er vlak boven. Voor de scoreketen laten 89, 90 en 91 zien of de A-grens correct is opgenomen. Test ook de algemene grenzen.

Valideer een score voordat je die beoordeelt: plaats score < 0 || score > 100 eerst en meld daar “Invalid score”. Latere takken werken dan alleen met geldige scores; 150 kan niet per ongeluk “A” krijgen. Validatie is een afzonderlijk eerste geval, geen correctie nadat de beoordeling al is gekozen.

Een switch kiest een case door één waarde met vaste labels te vergelijken. Dit past bij benoemde commando’s en genummerde keuzes. Gebruik een else if-keten als de keuze afhangt van een bereik of meerdere variabelen.

Vergelijk exacte waarden

Een switch op waarde accepteert selectiewaarden van de typen char, byte, short, int, de bijbehorende wrappertypen, String en enumtypen. Zonder experimentele functies worden selectiewaarden van de typen long, float, double en boolean niet ondersteund. Labels moeten constanten zijn: een voorwaarde zoals score >= 90 is geen waardelabel.

switch (day) {
    case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
    case 6, 7 -> System.out.println("Weekend");
    default -> System.out.println("Invalid day");
}

Een case met een pijl voert alleen de eigen code uit, zonder door te vallen. Komma’s groeperen meerdere labels voor één actie. Een dag met waarde 6 drukt “Weekend” af; bij 9 komt geen vermelde waarde overeen en wordt “Invalid day” afgedrukt.

Stringlabels komen overeen bij een exacte, hoofdlettergevoelige inhoud. Een commando “Start” komt niet overeen met case "start". Een dubbel label is een compilatiefout en één switch kan cases met pijlen en cases met dubbele punten niet combineren.

Lever een waarde op

Een switch-expressie berekent een resultaat:

int days = switch (month) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11 -> 30;
    case 2 -> 28;
    default -> 0;
};

In een niet-schrikkeljaar geeft maand 9 de waarde 30, maand 2 de waarde 28 en de ongeldige maand 13 de waarde 0. De puntkomma na de afsluitende accolade beëindigt de variabeledeclaratie.

Een expressie moet volledig zijn: elke mogelijke selectiewaarde moet een resultaat hebben. Neem voor deze voorbeelden met int en String een default op. Een switch-instructie op waarde mag default weglaten; bij een waarde zonder overeenkomst wordt dan geen case uitgevoerd. Een expressie die een waarde oplevert, kan het opleveren van een resultaat niet zomaar overslaan.

Geef een blok een resultaat met yield

Een case die een berekening uitvoert voordat die een waarde kiest, heeft een blok nodig:

int days = switch (month) {
    case 2 -> {
        boolean leap = (year % 4 == 0 && year % 100 != 0)
                || year % 400 == 0;
        yield leap ? 29 : 28;
    }
    case 4, 6, 9, 11 -> 30;
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    default -> 0;
};

yield levert de waarde van de case aan de switch-expressie. Februari geeft 29 in 2024 en 28 in 2026. Een enkele expressie na een pijl, zoals case 2 -> 28;, heeft geen yield nodig.

Lees de oudere vorm met dubbele punten

switch (level) {
    case 1:
        System.out.println("Bronze");
    case 2:
        System.out.println("Silver");
        break;
    case 3:
        System.out.println("Gold");
        break;
}

Bij niveau 1 gaat de uitvoering de eerste case binnen en verder naar de tweede, waardoor zowel “Bronze” als “Silver” wordt afgedrukt. Dit is doorvallen: een label met een dubbele punt stopt de uitvoering niet. break beëindigt de switch. Opeenvolgende labels met dubbele punten kunnen bewust een actie delen; een ontbrekende break na een actie kan ervoor zorgen dat de volgende per ongeluk wordt uitgevoerd.

Een switch op een char kan 'a', 'e', 'i', 'o', 'u' groeperen tot een resultaat “vowel”, waarbij default “other” geeft. Hetzelfde principe van exacte waarden geldt voor tekens, commando’s en numerieke keuzes.

Een while-lus test de voorwaarde vóór elke doorgang. Als de voorwaarde waar is, voert Java de body uit en keert terug naar de test. Als die onwaar is, gaat de uitvoering verder na de lus. Een onware eerste test betekent nul doorgangen.

Volg begin, test, body en bijwerking

int i = 1;
while (i <= 5) {
    System.out.println(i);
    i++;
}

De beginwaarde is 1. Elke doorgang drukt de huidige waarde af en verhoogt die daarna. De vijfde doorgang drukt 5 af en verandert i in 6. De volgende test is onwaar, dus de lus eindigt. De body wordt vijf keer uitgevoerd, maar de voorwaarde wordt zes keer getest: één keer vóór elke doorgang en een laatste onware test.

Een tellus heeft een beginwaarde nodig, een test en een bijwerking die naar het stoppen toe werkt. Laat je i++ weg, dan drukt deze lus oneindig 1 af. Een onbedoelde puntkomma is een andere valkuil: in while (i <= 5); is de lege instructie de body. Als i binnen het bereik begint, wordt het latere blok nooit bereikt en kan het de variabele niet bijwerken.

Stop als een grens wordt overschreden

Gelijkheid is vaak een kwetsbare stoptest. Als je bij 0 begint en 3 optelt, doorloop je 0, 3, 6, 9, 12, enzovoort. De test i != 10 kan niet opmerken dat 10 wordt overschreden, omdat 10 wordt overgeslagen. De test i < 10 eindigt na het verwerken van 9. Kies een grens die past bij de richting van de bijwerking.

Sommige lussen herhalen een onbekend aantal keren. Bijvoorbeeld:

int amount = 1;
int days = 0;
while (amount < 1000) {
    amount *= 2;
    days++;
}

Elke doorgang verdubbelt de hoeveelheid en telt één dag. Na negen doorgangen is de hoeveelheid 512; na tien is die 1024. Door de onware test bij 1024 blijft days gelijk aan 10. Een lus kan boven de drempelwaarde eindigen als de bijwerking grotere stappen neemt.

Lees voordat je beslist of je stopt

while (true) {
    String line = scanner.nextLine();
    if (line.equals("stop")) {
        break;
    }
    System.out.println("You wrote: " + line);
}

Hier is scanner de Scanner voor invoer. De lus leest een regel, controleert op “stop” en geeft alleen gewone regels weer. Het stopcommando wordt gelezen maar niet verwerkt. while (true) heeft een bereikbaar punt nodig waarop de lus wordt verlaten om te eindigen; een lus die blijft herhalen zonder te worden verlaten, is een oneindige lus.

Volg de veranderende toestand

Bekijk een product:

int n = 3;
int product = 1;
while (n > 0) {
    product *= n;
    n--;
}

De vermenigvuldiging gebruikt de oude n en daarna volgt het decrement. Als je het decrement boven de vermenigvuldiging zou zetten, zouden andere waarden worden vermenigvuldigd.

Declareer een lopend resultaat vóór de lus, zodat het van doorgang tot doorgang behouden blijft. Een variabele die binnen de body is gedeclareerd, wordt opnieuw aangemaakt telkens wanneer de uitvoering de declaratie bereikt. Druk binnen de body af om tussenresultaten te zien; druk na de afsluitende accolade af om het eindresultaat één keer te tonen.

Een do-while-lus voert de body uit voordat wordt gecontroleerd of een volgende doorgang nodig is. Gebruik die als de eerste actie moet plaatsvinden, zoals het tonen van een menu of het vragen om een invoerwaarde.

Test na de eerste actie

int i = 10;
do {
    System.out.println(i);
    i++;
} while (i < 5);

De body drukt 10 af en verhoogt i naar 11. Pas dan test Java i < 5. Dat is onwaar, dus er is geen tweede doorgang. Een while (i < 5)-lus die bij 10 begint, zou niets afdrukken.

De puntkomma na de laatste while (...) is verplicht. Die sluit de do-while-instructie af. Dit verschilt van de onbedoelde puntkomma na de kop van een while met een vooraf geteste voorwaarde, die een lege lusbody maakt.

Herhaal zolang invoer ongeldig is

int rating;
do {
    System.out.print("Rating (1-5): ");
    rating = Integer.valueOf(scanner.nextLine());
} while (rating < 1 || rating > 5);

De vraag verschijnt vóór de eerste controle, zodat de gebruiker de waarde kan invoeren die wordt gecontroleerd. Bij invoer 7, dan 0 en dan 4 zijn de eerste twee voorwaarden waar en verschijnt de vraag opnieuw. De laatste voorwaarde is onwaar, dus de lus eindigt met rating gelijk aan 4.

De voorwaarde beschrijft doorgaan, niet accepteren. Een geldige beoordeling voldoet aan rating >= 1 && rating <= 5. De lus herhaalt zolang die uitspraak onwaar is, wat de wetten van De Morgan herschrijven als rating < 1 || rating > 5. Een EN-verbinding tussen deze buitengrenzen zou nooit waar zijn: één getal kan niet tegelijk onder 1 en boven 5 liggen.

Declareer de te controleren variabele vóór het blok

De afsluitende accolade beëindigt het bereik van de body voordat de voorwaarde wordt geëvalueerd. Een declaratie zoals int rating binnen het do-blok zou daarom niet beschikbaar zijn in de laatste voorwaarde. Declareer de variabele vóór do en wijs de invoer binnen de body toe. De toewijzing wordt altijd vóór de eerste test uitgevoerd.

Dezelfde plaatsing is van belang als de geaccepteerde waarde daarna wordt gebruikt. rating blijft na de hele lus binnen bereik en bevat nu de laatst gelezen waarde.

Houd een menu open

String choice;
do {
    System.out.println("a: show status, q: quit");
    choice = scanner.nextLine();
    if (choice.equals("a")) {
        System.out.println("Ready");
    }
} while (!choice.equals("q"));

Elke doorgang toont het menu en leest een keuze. Als je “a” invoert, wordt “Ready” afgedrukt en herhaalt de lus. Als je “q” invoert, wordt de actie overgeslagen en eindigt de lus bij de voorwaarde. Een onbekend commando leidt ook tot herhaling, omdat het geen “q” is.

Als de body geen continue bevat die op de lus betrekking heeft, kun je een do-while herschrijven als while (true) met onderaan een break op basis van de ontkende voorwaarde. Een continue vraagt bij zo’n herschrijving bijzondere aandacht: in de oorspronkelijke do-while springt die naar de voorwaarde, terwijl die in een while-true-lus naar boven springt en de toegevoegde test onderaan kan overslaan.

Een for-lus brengt de besturing van een teltaak samen in één kop. Die is nuttig als je het bereik of het aantal doorgangen kent voordat de herhaling begint.

Lees de kop in uitvoeringsvolgorde

for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

De initialisatie wordt één keer uitgevoerd en zet i op 1. Java test i <= 5, voert de body uit als de voorwaarde waar is, voert i++ uit en keert terug naar de test. De bijwerking staat in de kop, maar wordt na de body uitgevoerd. De laatste onware test beëindigt de lus.

Bij gewoon tellen hebben i++ en ++i op de plaats van de bijwerking hetzelfde effect, omdat de waarde van geen van beide expressies wordt gebruikt. Houd de wijzigingen van de teller in de kop, zodat de reeks gemakkelijk te voorspellen is.

Kies de eerste en laatste waarde

Bij opwaartse stappen van één, met een eindwaarde die minstens zo groot is als de beginwaarde, geeft een exclusieve eindgrens eindwaarde min beginwaarde doorgangen; een inclusieve eindgrens voegt er één toe. Bij grotere stappen moet je de werkelijk bereikte waarden opsommen of tellen. Een aftellende lus moet in de bijpassende richting testen: beginnen bij 10 met i <= 1 geeft nul doorgangen.

Een één-ernaastfout neemt één ongewenst eindpunt mee of laat er één weg. Om 1 tot en met 10 af te drukken, mist i < 10 de 10; gebruik i <= 10. Controleer de eerste en laatste waarde in de body en de eerste waarde die niet aan de voorwaarde voldoet.

Bouw een resultaat op over een bereik

int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println(sum);

De body telt elk geheel getal één keer op en eindigt met 5050. Een product begint anders: initialiseer product op 1 voordat je met 1 tot en met 5 vermenigvuldigt. Dat geeft 120; beginnen bij 0 zou het product na elke vermenigvuldiging op 0 laten.

Let op bereik en lege body’s

Een teller die in de kop is gedeclareerd, bestaat gedurende die lus, maar niet na de afsluitende accolade. Declareer de teller eerder als latere code de eindwaarde nodig heeft.

Een puntkomma direct na de kop is een lege body. In for (int i = 0; i < 3; i++); wordt de lege instructie drie keer uitgevoerd. Een volgend blok dat “Hello” afdrukt, wordt één keer na de lus uitgevoerd, niet drie keer. Accolades horen direct na de kop.

Elk onderdeel van de kop mag worden weggelaten. for (;;) { ... } heeft geen stopvoorwaarde en gedraagt zich als while (true); de lus heeft een manier om te stoppen nodig, zoals break.

Kies de duidelijkste lus

De vormen kunnen dezelfde herhaling uitdrukken, maar bij herschrijven moet de volgorde van tests en bijwerkingen behouden blijven, inclusief wat een continue overslaat.

Door een lus voortijdig te verlaten, kun je de herhaling stoppen zodra de taak klaar is. Door een doorgang over te slaan, kun je ongewenst werk weglaten terwijl de lus doorgaat. Let goed op waar de uitvoering naartoe gaat: break en continue doen verschillende dingen.

Beëindig een zoekactie met break

for (int n = 51; n <= 100; n++) {
    if (n % 7 == 0) {
        System.out.println(n);
        break;
    }
}

De waarden 51 tot en met 55 voldoen niet aan de deelbaarheidstest. De volgende waarde, 56, wordt afgedrukt en break verlaat de lus direct. De bijwerking wordt na die break niet uitgevoerd. Zonder break zouden ook latere veelvouden zoals 63 en 70 worden afgedrukt.

Een break zonder label richt zich op de dichtstbijzijnde omringende lus of switch. De uitvoering gaat verder na die constructie, niet na het hele programma.

Sla over met continue

for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        continue;
    }
    System.out.print(i + " ");
}

Voor 3, 6 en 9 slaat continue de afdrukinstructie over. In een for-lus wordt de bijwerking in de kop nog steeds uitgevoerd, gevolgd door de voorwaarde. De uitvoer bevat 1, 2, 4, 5, 7, 8 en 10.

Bij een while of do-while gaat continue naar de voorwaarde. Een eventuele bijwerking eronder in de body wordt overgeslagen. Als een while-teller bij 0 begint en de eerste actie if (i % 3 == 0) { continue; } is, wordt een i++ later in de body nooit bereikt. De teller blijft 0 en de lus herhaalt oneindig. Verplaats de vereiste bijwerking naar vóór elk pad dat wordt overgeslagen, of gebruik een for-kop om de bijwerking automatisch te laten verlopen.

Verlaat geneste lussen bewust

Een gewone break binnen een binnenste lus beëindigt alleen die binnenste lus. Met een label kun je een buitenste lus aanwijzen als doel om te verlaten:

outer:
for (int a = 1; a <= 10; a++) {
    for (int b = 1; b <= 10; b++) {
        if (a * b == 24 && a + b == 10) {
            System.out.println("Found " + a + " and " + b);
            break outer;
        }
    }
}

De zoekactie doorloopt paren op volgorde. Bij a = 4 en b = 6 slagen beide tests en verlaat de break met label beide lussen. continue outer zou in plaats daarvan naar de bijwerking van de buitenste lus en dan naar de volgende test gaan.

Onderscheid het verlaten van een switch van het verlaten van een lus

In een menulus met een switch met dubbele punten beëindigt break binnen een case de switch. Die beëindigt op zichzelf niet de omringende lus. Een duidelijk patroon zet in de case voor afsluiten een lusvlag op false en gebruikt vervolgens break om de switch te verlaten. De lus eindigt als de volgende voorwaardecontrole ziet dat de vlag onwaar is. Cases met pijlen hebben geen break nodig om doorvallen te voorkomen.

Een break zonder label is toegestaan binnen een lus of switch; continue is toegestaan binnen een lus. Als je ze elders plaatst, compileert de code niet. Houd de normale stopregel in de lusvoorwaarde als die daar past. Gebruik while (true) met een break als de stoptest van nature na het lezen van invoer maar vóór de verwerking ervan hoort. Meerdere punten om de lus te verlaten kunnen nuttig zijn, maar elk extra pad voegt toestand toe die je bij het volgen van de uitvoering moet bijhouden.

Een teller houdt bij hoeveel waarden aan een voorwaarde voldoen. Een accumulator combineert waarden tot een lopend resultaat. Declareer beide vóór de lus, zodat elke doorgang voortbouwt op het eerdere werk.

Initialiseer voor de bewerking

Gebruik int count = 0; en verhoog de teller als een element voldoet. Een som begint bij 0 en gebruikt sum += value;. Een product begint bij 1, omdat vermenigvuldigen met een beginwaarde van 0 elke latere factor teniet zou doen. Als je een totaal binnen de body initialiseert, wordt het bij elke doorgang teruggezet.

Bij een bereik kan de stap van de lus de waarden selecteren: als je de even gehele getallen van 2 tot en met 100 in stappen van 2 optelt, krijg je 2550. Je kunt ook een voorwaarde binnen de lus plaatsen. Het aantal getallen van 1 tot en met 100 dat deelbaar is door 3 of door 5 is 47: de zes veelvouden van 15 mogen maar één keer worden geteld.

Stop vóór het optellen van de invoer

Een stopwaarde is een speciale invoerwaarde die het lezen beëindigt. Het is geen gewone gegevenswaarde:

int sum = 0;
int count = 0;
while (true) {
    int number = Integer.valueOf(scanner.nextLine());
    if (number == 0) {
        break;
    }
    sum += number;
    count++;
}

Bij de invoer 12, 7, 5, 0 verloopt de som via 12 en 19 naar 24. De teller bereikt 3. De laatste 0 activeert de break voordat een van beide variabelen verandert. Als je die meetelt, ontstaat een vierde element en krijg je een verkeerd gemiddelde, ook al verandert de som niet door nul op te tellen.

Deel pas nadat je het aantal hebt gecontroleerd

if (count > 0) {
    double average = (double) sum / count;
    System.out.println(average);
} else {
    System.out.println("No numbers entered");
}

Het voorbeeld drukt 8.0 af. Bij gehele operanden laat de deling het breukdeel vervallen: 25 / 4 is 6. Zet vóór het delen om om 6,25 te krijgen: (double) sum / count. Achteraf een expliciete typeconversie uitvoeren, (double) (sum / count), zet alleen het al afgekapt resultaat om naar 6,0.

Als de stopwaarde als eerste komt, is het aantal 0. Geheeltallige deling door nul werpt een ArithmeticException op; een zwevendekommasom van nul gedeeld door nul geeft NaN. De controle van het aantal voorkomt dat lege invoer een betekenisloos gemiddelde oplevert.

Houd meerdere resultaten bij in één doorgang

Voor de scores 55, 72, 90, 48 en 81 levert een slaaggrens van 60 vijf scores en drie voldoendes op. Houd een totaalteller bij voor elke score en een teller voor voldoendes binnen de voorwaarde voor slagen. 100.0 * passed / total geeft 60,0 procent; door 100.0 wordt met zwevendekommagetallen gerekend. Controleer ook vóór deze deling of het totaal positief is.

De plaats waar je afdrukt, verandert wat wordt getoond. Afstanden van 5, 3 en 8 km geven lopende totalen van 5, 8 en 16 km als je die binnen de lus na het optellen afdrukt. Als je daarna afdrukt, krijg je alleen de uiteindelijke 16 km.

Kies een type dat groot genoeg is voor het totaal

Het maximum van een int is 2.147.483.647. Alle gehele getallen van 1 tot en met 100.000 optellen zou 5.000.050.000 moeten opleveren, maar een int springt zonder foutmelding naar 705.082.704. long sum = 0; bevat deze som correct; het maximum van long is ongeveer 9,2 × 10¹⁸. Als je een resultaat dat al is overgelopen achteraf via een verbredende typeconversie omzet, kun je de verloren waarde niet herstellen.

Sommige lussen onthouden een beste waarde; andere onthouden of er een overeenkomst is gevonden. Kies de begintoestand zo dat die vóór en na elke doorgang klopt.

Houd de beste waarde tot dan toe bij

Om een maximum bij te houden, vervang je het alleen als de huidige waarde groter is: if (value > max) { max = value; }. Als je met de eerste meting begint, leveren de temperaturen 14, 19, 11, 23 en 17 °C achtereenvolgens de maxima 14, 19, 19, 23 en 23 °C op. Een minimum gebruikt in plaats daarvan <.

Een maximum bij 0 laten beginnen werkt niet als alle gegevens negatief zijn: -5, -2 en -9 zouden ten onrechte 0 als resultaat overlaten. Initialiseer vanuit een werkelijke meting, of begin met Integer.MIN_VALUE voor een int-maximum en Integer.MAX_VALUE voor een int-minimum. Meld dat er geen resultaat is als er geen metingen waren.

Om een positie vast te leggen, werk je die bij in dezelfde tak als de waarde. Een strikte > behoudt bij gelijke waarden het eerste maximum; >= vervangt het opnieuw en behoudt het laatste.

Stop nadat je een overeenkomst hebt gevonden

int n = 1;
while (n * n <= 500) {
    n++;
}

Bij 22 is het kwadraat 484, dus volgt nog een doorgang. Bij 23 is het 529 en voldoet de voorwaarde niet meer. De lus heeft het kleinste positieve gehele getal gevonden waarvan het kwadraat groter is dan 500. Een begrensde zoekactie kan in plaats daarvan elke kandidaat in een for-lus testen en bij de eerste overeenkomst stoppen met break.

Voor een vraag of een waarde voldoet, begin je met een onware vlag en maak je die waar bij een overeenkomst. Voor een vraag of alle waarden voldoen, begin je met waar en maak je de vlag onwaar bij een tegenvoorbeeld. Zet de vlag bij latere waarden niet terug in een else-tak: een latere waarde die niet overeenkomt, maakt bijvoorbeeld een eerdere negatieve meting niet ongedaan.

Test op een deler

Een priemgetal is minstens 2 en heeft geen deler van 2 tot en met één minder dan het getal zelf. Voor een klein positief geheel getal test een kortere controle delers slechts tot en met de vierkantswortel:

int n = 91;
boolean isPrime = n >= 2;
for (int d = 2; d * d <= n; d++) {
    if (n % d == 0) {
        isPrime = false;
        break;
    }
}

Twee factoren van een getal kunnen niet allebei groter zijn dan de vierkantswortel. Voor 91 geeft deler 7 een rest van nul en verandert de vlag in onwaar. Voor 97 deelt geen deler van 2 tot en met 9 het getal zonder rest, dus blijft de vlag waar. Waarden onder 2 beginnen met een onware vlag. Gebruik voor grote positieve int-waarden d <= n / d om overloop in d * d te voorkomen.

Verwijder één decimaal cijfer per doorgang

Voor een niet-negatief geheel getal haalt % 10 het laatste cijfer op en verwijdert de geheeltallige deling / 10 dat cijfer:

int n = 4072;
int sum = 0;
while (n > 0) {
    sum += n % 10;
    n /= 10;
}

De cijfers zijn 2, 7, 0 en 4, wat 13 oplevert. De gebruikte n eindigt op 0. Om de cijfers om te keren, werk je reversed = reversed * 10 + n % 10; bij voordat je het cijfer verwijdert; 1234 wordt 4321 als het resultaat in het gekozen type past.

Om cijfers te tellen, heeft nul één doorgang nodig, ook al is n > 0 aan het begin onwaar. Gebruik een do-while die de teller verhoogt en n door 10 deelt. Die telt één cijfer voor 0 en het gebruikelijke aantal voor positieve waarden.

Geneste lussen herhalen een volledige herhaling voor elke buitenste doorgang. Ze zijn nuttig voor rijen, kolommen, tabellen en vormen. De binnenste lus moet opnieuw beginnen telkens wanneer de buitenste lus die bereikt.

Druk een rij af en beëindig dan de regel

for (int row = 1; row <= 3; row++) {
    for (int col = 1; col <= 5; col++) {
        System.out.print(row * col + "\t");
    }
    System.out.println();
}

De eerste rij bevat 1, 2, 3, 4, 5; de tweede bevat 2, 4, 6, 8, 10; de derde bevat 3, 6, 9, 12, 15. De print binnen de lus maakt kolommen op één regel; de println na de binnenste lus beëindigt die rij. Als je println binnen de binnenste lus zet, komt elk product op een eigen regel.

Bij vaste aantallen vermenigvuldig je het aantal buitenste doorgangen met het aantal binnenste doorgangen. Drie buitenste doorgangen en vier binnenste doorgangen voeren de binnenste body 12 keer uit. In de tabel hierboven worden drie keer vijf, ofwel 15, producten afgedrukt.

Laat de rijgrootte veranderen

for (int row = 1; row <= 4; row++) {
    for (int col = 1; col <= row; col++) {
        System.out.print("*");
    }
    System.out.println();
}

De binnenste grens hangt nu af van de rij. De aantallen zijn 1, 2, 3 en 4, dus de driehoek bevat 10 sterren. Eén vermenigvuldiging van vaste aantallen zou verkeerd zijn, omdat de binnenste lus niet op elke rij even vaak wordt uitgevoerd.

Gebruik verschillende namen voor lustellers waarvan het bereik overlapt. Een tweede int i declareren binnen een lus waarin i al binnen bereik is, levert een compilatiefout op. Initialiseer bij een binnenste while-lus de teller aan het begin van elke buitenste doorgang. Als je die alleen vóór de buitenste lus initialiseert, blijft de teller na de eerste rij voorbij de grens staan.

Volg waarden op een vast moment

Trek voor een lus van 1 tot en met 4 oneven waarden af van een totaal dat bij 0 begint en tel even waarden op:

Leg vast of een rij het begin of het einde van een doorgang beschrijft. Neem bij het controleren of de lus eindigt ook de laatste mislukte voorwaardetest mee. Een traceertabel die waarden van vóór en na de bijwerking door elkaar gebruikt, kan een correcte lus fout laten lijken.

Zet scheidingstekens tussen elementen

Vijf getallen hebben vier komma’s nodig. Druk vóór elk element behalve het eerste een scheidingsteken af:

for (int i = 1; i <= 5; i++) {
    if (i > 1) {
        System.out.print(", ");
    }
    System.out.print(i);
}

De uitvoer is “1, 2, 3, 4, 5”, zonder komma aan het begin of einde. Dit is een hekpalenprobleem: het aantal tussenruimten verschilt van het aantal elementen.

Test gevallen die fouten blootleggen

Probeer nul doorgangen, één doorgang en de waarden op en naast elke grens. Probeer bij invoerlussen eerst de stopwaarde. Controleer bij geneste lussen of de tweede rij correct opnieuw begint. Tijdelijk afdrukken van de lusvariabelen laat de werkelijke voortgang zien. Als een programma blijft hangen, controleer dan elk pad op een bijwerking of uitgang en stop het met Ctrl+C in een terminal of met de stopknop van de ontwikkelomgeving.