Java while-Schleife: Syntax, do-while und häufige Fallstricke

Wenn du keinen Zähler hast

Die for-Schleife ist um einen Zähler herum aufgebaut, den du vorab festlegst. Doch viele Schleifen haben keine saubere Zählung: weiter Zeilen lesen, bis die Datei endet, weiter nach einem Passwort fragen, bis es stimmt, eine Zahl immer wieder halbieren, bis sie 1 erreicht. Für solche Fälle passt die while-Schleife ganz natürlich - sie wiederholt einfach, solange eine Bedingung wahr bleibt.

Eine while-Schleife prüft ihre Bedingung vor jedem Durchlauf, auch dem allerersten. Ist die Bedingung von Anfang an falsch, läuft der Rumpf gar nicht.

public class Main {
    public static void main(String[] args) {
        int count = 3;

        while (count > 0) {
            System.out.println("Liftoff in " + count);
            count--;
        }

        System.out.println("Go!");
    }
}

Die Bedingung count > 0 wird zuerst geprüft; ist sie wahr, läuft der Rumpf; dann springen wir zurück und prüfen erneut. Die Zeile count-- ist das, was die Bedingung schließlich falsch macht - lass sie weg, und die Schleife läuft endlos.

Die Anatomie einer while-Schleife

Vergleiche sie mit der dreiteiligen for-Schleife, die du bereits kennst. Eine while-Schleife trennt diese drei Aufgaben: die Initialisierung machst du vor der Schleife, die Bedingung steht in den Klammern und die Aktualisierung lebt innerhalb des Rumpfs.

int i = 0;              // Initialisierung - vor der Schleife
while (i < 5) {         // Bedingung - bei jedem Durchlauf geprüft
    System.out.println(i);
    i++;                // Aktualisierung - daran musst du selbst denken
}

Dieser letzte Teil ist der Haken. In einer for-Schleife sitzt die Aktualisierung direkt neben der Bedingung, daher ist sie schwer zu vergessen. In einer while-Schleife ist sie nur eine weitere Anweisung im Rumpf - der häufigste Fehler ist, sie wegzulassen und das Programm hängen zu lassen.

do-while: den Rumpf mindestens einmal ausführen

Manchmal musst du den Rumpf einmal ausführen, bevor du überhaupt entscheiden kannst, ob du wiederholst. Die do-while-Schleife prüft ihre Bedingung am Ende, daher läuft der Rumpf immer mindestens einmal:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int number;

        do {
            System.out.print("Enter a positive number: ");
            number = in.nextInt();
        } while (number <= 0);

        System.out.println("Thanks! You entered " + number);
    }
}

Du musst mindestens einmal fragen und einlesen, bevor du wissen kannst, ob die Eingabe gültig ist - genau das gibt dir do-while. Beachte das Semikolon nach while (...) - es ist erforderlich, und es zu vergessen ist ein häufiger Kompilierfehler.

Der Unterschied zu einem einfachen while zeigt sich deutlich, wenn die Bedingung von Anfang an falsch ist:

public class Main {
    public static void main(String[] args) {
        int x = 10;

        // while: Bedingung von vornherein falsch -> Rumpf läuft nie
        while (x < 5) {
            System.out.println("while body");
        }

        // do-while: läuft einmal, DANN wird geprüft -> Rumpf läuft genau einmal
        do {
            System.out.println("do-while body");
        } while (x < 5);
    }
}

Nur do-while body wird ausgegeben. Die while-Schleife überspringt ihren Rumpf vollständig, weil x < 5 vor der ersten Prüfung falsch war.

Schleifen bis zu einem Sentinel-Wert

Eine klassische Verwendung von while ist das Lesen bis zu einem speziellen "Stopp"-Wert - einem Sentinel. Hier gibt es keinen Zähler; du machst einfach weiter, bis die Daten dir sagen, dass du aufhören sollst:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = 0;

        System.out.println("Enter numbers to add (0 to finish):");
        int value = in.nextInt();

        while (value != 0) {
            sum += value;
            value = in.nextInt();
        }

        System.out.println("Total: " + sum);
    }
}

Das Muster lautet einmal vor der Schleife lesen, dann am Ende jedes Durchlaufs erneut lesen. So prüft die Bedingung stets eine frische Eingabe. Wenn du das zweite Lesen im Rumpf vergisst, ändert sich value nie und du hast eine Endlosschleife.

break und continue in while-Schleifen

break und continue funktionieren hier genauso wie in einer for-Schleife. break verlässt die Schleife sofort; continue springt direkt zur Bedingungsprüfung und überspringt den Rest des aktuellen Durchlaufs:

public class Main {
    public static void main(String[] args) {
        int n = 0;

        while (true) {              // absichtliche "Endlosschleife"
            n++;
            if (n % 2 == 0) continue;   // gerade Zahlen überspringen
            if (n > 9) break;           // stoppen, sobald über 9
            System.out.println(n);
        }
    }
}

Dies gibt 1 3 5 7 9 aus. Das while (true) hört absichtlich nie von selbst auf - das break ist der einzige Ausgang. Sei vorsichtig mit continue in einer while-Schleife: Da die Aktualisierung Teil des Rumpfs ist, ist das Zurückspringen an den Anfang mit continue, bevor du deinen Zähler vorgerückt hast, eine stille Art, die Schleife hängen zu lassen. Im obigen Beispiel läuft n++ zuerst, also ist es sicher.

Vorsicht vor Endlosschleifen

Die Bedingung muss irgendwann falsch werden, und das hängt völlig davon ab, dass sich etwas im Rumpf ändert. Die beiden üblichen Übeltäter sind, die Aktualisierung zu vergessen und auf die falsche Weise zu aktualisieren:

int i = 0;
while (i < 5) {
    System.out.println(i);   // i ändert sich nie -> läuft endlos
}

int i = 0;
while (i != 10) {
    i += 3;   // 0, 3, 6, 9, 12... springt direkt an 10 vorbei -> läuft endlos
}

Das erste hängt, weil i nie aktualisiert wird. Das zweite hängt, weil der Zähler genau über den Wert hinwegspringt, nach dem die Bedingung sucht - bevorzuge < oder <= gegenüber !=, wenn der Schritt nicht exakt landen könnte. Ein while (true) ist in Ordnung, wenn es ein garantiertes break hat; ein versehentliches ist nur ein Fehler.

Weiter: die for-each-Schleife

Eine while-Schleife ist das richtige Werkzeug, wenn du schleifst, bis sich eine Bedingung ändert, und es keine saubere Zählung gibt. Aber wenn du einfach jedes Element eines Arrays oder einer Liste besuchen willst - kein Index, keine zu verwaltende Bedingung - gibt es etwas noch Saubereres: die erweiterte for-each-Schleife. Das ist die nächste Seite.