Break/Continue

Kurz: Zwei Sprunganweisungen zur Ablaufsteuerung innerhalb von Schleifen: break verlässt die Schleife komplett, continue überspringt nur den Rest des aktuellen Durchlaufs.

Genauer: break wird auch in switch-Statements genutzt, um den Fallthrough zwischen Cases zu verhindern. Bei verschachtelten Schleifen wirken beide standardmäßig nur auf die innerste Schleife — mit benannten Labels (aussen: for (...) { ... break aussen; }) lässt sich das gezielt auf eine äußere Schleife ausweiten.

Im Detail

outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 1) continue;        // überspringt Rest NUR der inneren Schleife
        if (i == 2) break outer;     // verlässt BEIDE Schleifen komplett
        System.out.println(i + "," + j);
    }
}

Ohne Label wirken break und continue immer nur auf die unmittelbar umschließende Schleife — bei tief verschachtelten Schleifen ein häufiger Logikfehler, wenn man eigentlich die äußere Schleife verlassen wollte. Labels (name: direkt vor der Schleife) lösen das explizit, werden aber in der Praxis selten genutzt, weil verschachtelte Schleifen mit Labels oft ein Zeichen dafür sind, dass sich die Logik besser in eine eigene Methode mit return auslagern lässt — ein return innerhalb einer Methode verlässt sofort die komplette Methode samt aller umschließenden Schleifen, ganz ohne Label.

break in switch-Statements

Neben Schleifen ist break auch zentral für klassische switch-Statements (nicht die neuere switch-Expression mit ->), um den sogenannten Fallthrough zu verhindern:

int tag = 3;
switch (tag) {
    case 1:
        System.out.println("Montag");
        break; // ohne break würde die Ausführung in case 2 "durchfallen"
    case 2:
        System.out.println("Dienstag");
        break;
    case 3:
        System.out.println("Mittwoch");
        break;
    default:
        System.out.println("Unbekannt");
}

Vergisst man break in einem case, läuft die Ausführung einfach in den nächsten case-Block weiter (“Fallthrough”) — ein klassischer, schwer zu findender Anfängerfehler, den moderne switch-Expressions (case 1 ->) seit Java 14 komplett vermeiden, da sie kein implizites Fallthrough mehr haben.

continue in der Praxis

continue wird oft genutzt, um “uninteressante” Fälle früh zu überspringen und den Hauptcode der Schleife nicht zusätzlich einzurücken (sogenannte “Guard Clause”):

for (String wort : woerter) {
    if (wort.isEmpty()) continue; // leere Einträge einfach ignorieren
    if (wort.startsWith("#")) continue; // Kommentare überspringen
    verarbeite(wort); // Hauptlogik bleibt übersichtlich, ohne tiefe if-Verschachtelung
}

Vergleich zu return

return und break werden von Einsteigern manchmal verwechselt: break verlässt nur die Schleife/das switch, der Code danach in der Methode läuft normal weiter. return verlässt sofort die GESAMTE Methode, egal wie viele Schleifen noch offen sind.

Häufiger Fallstrick: continue in for-each-Schleifen

In einer for-each-Schleife (for (String s : liste)) funktioniert continue genauso wie in einer klassischen for-Schleife, ABER: Modifikationen an der Iterationsvariable s selbst (z. B. s = "anders") haben keinerlei Effekt auf die Ursprungsliste, da s nur eine lokale Kopie der Referenz für den aktuellen Durchlauf ist. Wer versucht, Elemente einer Liste während einer for-each-Iteration zu entfernen, bekommt stattdessen eine ConcurrentModificationException — dafür ist ein expliziter Iterator mit iterator.remove() nötig.

Endlosschleifen bewusst mit break beenden

Ein verbreitetes Muster ist eine absichtliche Endlosschleife, die nur über eine break-Bedingung im Inneren verlassen wird — nützlich, wenn die Abbruchbedingung mitten im Schleifenkörper geprüft werden muss, nicht am Anfang:

while (true) {
    String eingabe = scanner.nextLine();
    if (eingabe.equals("exit")) break;
    verarbeite(eingabe);
}

Das ist oft lesbarer als eine komplizierte Bedingung direkt im while-Kopf, besonders wenn die Abbruchbedingung erst nach einer Aktion (hier: dem Einlesen) bekannt ist.

Siehe auch: Schleifen, Switch-Statement