Java Continue-statement

Deze tutorial legt Java's continue en gelabelde continue-statements uit, compleet met duidelijke voorbeelden om lus-flow efficiënt te controleren.

Terwijl je met lussen werkt, wil je soms bepaalde statements overslaan of de lus vroegtijdig beëindigen. In dergelijke gevallen zijn de break- en continue-statements de tools die je zult gebruiken.

Om te leren over de break-statement, bezoek Java break. Hier richten we ons op de continue-statement.

Java continue

De continue-statement slaat de huidige iteratie van een lus over (for, while, do…while, etc.). Na de continue-statement springt het programma naar de lus-beëindigingscheck (en voor for-lussen, de update-expressie).

Hier is de syntax:

continue;

Let op: De continue-statement wordt meest gebruikt binnen conditionele blokken (bijv. if-statements).

Werking van Java continue-statement

Voorbeeld 1: Java continue-statement

class Main {
    public static void main(String[] args) {
        // for-lus
        for (int i = 1; i <= 10; ++i) {
            // als waarde van i tussen 4 en 9 ligt
            // wordt continue uitgevoerd
            if (i > 4 && i < 9) {
                continue;
            }
            System.out.println(i);
        }
    }
}

Output:

1
2
3
4
9
10

In dit programma print een for-lus de waarde van i voor elke iteratie. De continue-statement activeert wanneer i groter is dan 4 en kleiner dan 9, wat ervoor zorgt dat de println-statement overgeslagen wordt voor 5, 6, 7 en 8.

Voorbeeld 2: Som van 5 positieve getallen berekenen

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Double number, sum = 0.0;
        // maak een object van Scanner
        Scanner input = new Scanner(System.in);
        for (int i = 1; i < 6; ++i) {
            System.out.print("Voer getal " + i + " in: ");
            // neem input van de gebruiker
            number = input.nextDouble();
            // als getal negatief is
            // wordt continue-statement uitgevoerd
            if (number <= 0.0) {
                continue;
            }
            sum += number;
        }
        System.out.println("Som = " + sum);
        input.close();
    }
}

Output:

Voer getal 1 in: 2.2
Voer getal 2 in: 5.6
Voer getal 3 in: 0
Voer getal 4 in: -2.4
Voer getal 5 in: -3
Som = 7.8

Hier slaat de continue-statement elke negatieve of nul-input over, zodat alleen positieve waarden bijdragen aan de totaal.

Let op: We gebruikten de Scanner-klasse om gebruikersinput te lezen. Lees meer: Java Scanner.

Java continue met geneste lussen

Wanneer lussen genest zijn, beïnvloedt een continue binnen de innerlijke lus alleen de huidige iteratie van die innerlijke lus.

Voorbeeld 3: continue met geneste lus

class Main {
    public static void main(String[] args) {
        int i = 1, j = 1;
        // outer lus
        while (i <= 3) {
            System.out.println("Outer Lus: " + i);
            // inner lus
            while(j <= 3) {
                if(j == 2) {
                    j++;
                    continue;
                }
                System.out.println("Inner Lus: " + j);
                j++;
            }
            i++;
        }
    }
}

Output

Outer Lus: 1
Inner Lus: 1
Inner Lus: 3
Outer Lus: 2
Outer Lus: 3

In dit voorbeeld slaat de continue binnen de innerlijke lus de iteratie over wanneer j gelijk is aan 2, wat "Inner Lus: 2" voorkomt te printen.

Gelabelde continue-statement

Naast de basis continue ondersteunt Java ook een gelabelde versie die de flow stuurt naar een specifieke lus. De syntax is:

continue label;

Dit zorgt ervoor dat het programma de huidige iteratie van de lus geïdentificeerd door label overslaat.

In de illustratie hierboven richt het label zich op de outer-lus, wat demonstreert hoe de continue een volledige iteratie van die lus kan overslaan.

Voorbeeld 4: gelabelde continue-statement

class Main {
    public static void main(String[] args) {
        // outer lus gelabeld als first
        first: for (int i = 1; i < 6; ++i) {
            // inner lus
            for (int j = 1; j < 5; ++j) {
                if (i == 3 || j == 2)
                    // sla huidige iteratie van outer lus over
                    continue first;
                System.out.println("i = " + i + "; j = " + j);
            }
        }
    }
}

Output:

i = 1; j = 1
i = 2; j = 1
i = 4; j = 1
i = 5; j = 1

Hier springt de gelabelde continue naar de volgende iteratie van de lus genaamd first wanneer i gelijk is aan 3 of j gelijk is aan 2.

Let op: Gelabelde continue kan krachtig zijn maar verlaagt vaak leesbaarheid. Overweeg refactoring om de flow helder te houden wanneer je zo'n nodig hebt.