Java for-Schleife: Syntax, Beispiele und das erweiterte for-each

Die klassische dreiteilige for-Schleife

Eine for-Schleife wiederholt einen Block eine kontrollierte Anzahl von Malen. Javas Form packt drei Dinge in die Klammern, getrennt durch Semikolons:

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

Die drei Teile laufen in einem festen Rhythmus ab:

1. Initialisierung (int i = 0) - läuft einmal, vor allem anderen.
2. Bedingung (i < 5) - wird vor jedem Durchlauf geprüft; die Schleife stoppt, wenn sie falsch ist.
3. Aktualisierung (i++) - läuft nach jedem Durchlauf, bevor die Bedingung erneut geprüft wird.

Das gibt also i = 0 bis i = 4 aus. Der Zähler i ist auf die Schleife beschränkt - er existiert nach der schließenden geschweiften Klammer nicht mehr.

Hoch-, Herunter- und in Schritten zählen

Die drei Teile geben dir volle Kontrolle über den Zähler:

public class Main {
    public static void main(String[] args) {
        for (int i = 10; i > 0; i--) {       // rückwärts zählen
            System.out.print(i + " ");
        }
        System.out.println();

        for (int i = 0; i <= 20; i += 5) {   // in 5er-Schritten
            System.out.print(i + " ");
        }
    }
}

i-- verringert, i += 5 springt in Fünferschritten. Die Bedingung entscheidet richtungsabhängig über das Stoppen: Verwende >, wenn du rückwärts zählst, und < oder <=, wenn du vorwärts zählst.

Ein Array durchlaufen

Eine gezählte Schleife passt von Natur aus zu einem Array, mit .length als Grenze und i als Index:

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        for (int i = 0; i < colors.length; i++) {
            System.out.println(i + ": " + colors[i]);
        }
    }
}

Beachte, dass colors.length ein Feld ohne Klammern ist - Arrays sind in dieser Hinsicht besonders. Eine List verwendet stattdessen list.size(). Die Bedingung i < colors.length ist korrekt: Indizes laufen von 0 bis length - 1, daher vermeidet die Verwendung von < (und nicht <=) einen Fehler durch Überschreitung der Grenzen.

Die erweiterte for-each-Schleife

Wenn du nur jedes Element und nie den Index brauchst, ist das erweiterte for sauberer und schwerer falsch zu machen - es gibt keinen Zähler, bei dem man sich um eins vertun könnte:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> colors = List.of("red", "green", "blue");

        for (String color : colors) {
            System.out.println(color.toUpperCase());
        }
    }
}

Lies for (String color : colors) als „für jedes color in colors". Es funktioniert mit Arrays und allem Iterierbaren. Der Kompromiss: Du hast keinen Index und kannst der Sammlung während des Durchlaufens nichts hinzufügen oder entfernen (das wirft ConcurrentModificationException). Greife zur gezählten Schleife, wenn du eines von beiden brauchst.

Verschachtelte Schleifen

Eine Schleife in einer Schleife - nützlich für Gitter, Tabellen und Paarungen. Die innere Schleife läuft bei jedem Durchlauf der äußeren vollständig durch:

public class Main {
    public static void main(String[] args) {
        for (int row = 1; row <= 3; row++) {
            for (int col = 1; col <= 3; col++) {
                System.out.print(row * col + "\t");
            }
            System.out.println();
        }
    }
}

Das gibt ein 3x3-Multiplikationsgitter aus. Gib den Zählern aussagekräftige Namen (row, col) statt i, j, sobald die Verschachtelung tief wird - das bewahrt dich davor, durcheinanderzubringen, welcher welcher ist.

break und continue

break verlässt die Schleife sofort. continue überspringt den Rest des aktuellen Durchlaufs und springt zum Aktualisierungsschritt:

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue;   // gerade Zahlen überspringen
            if (i > 7) break;           // stoppen, sobald über 7
            System.out.println(i);
        }
    }
}

Das gibt 1 3 5 7 aus. continue überspringt die geraden Zahlen; break beendet die Schleife, sobald i 7 überschreiten würde. In verschachtelten Schleifen wirken beide nur auf die innerste Schleife, es sei denn, du verwendest einen mit Label versehenen break.

Vorsicht vor Endlosschleifen

Wenn die Bedingung nie falsch wird, läuft die Schleife ewig. Die übliche Ursache ist, die Aktualisierung zu vergessen oder den Zähler in die falsche Richtung zu bewegen:

for (int i = 0; i < 5; i--) {   // i nimmt nur ab -> erreicht nie 5
    System.out.println(i);
}

Eine absichtliche Endlosschleife lässt alle drei Teile weg -for (;;) { ... }- und verlässt sich auf ein break im Inneren, um anzuhalten. Verwende das sparsam; ein while (true) liest sich meist klarer.

Als Nächstes: while-Schleifen

Die for-Schleife glänzt, wenn du den Zähler im Voraus kennst. Wenn du schleifen möchtest, bis sich eine Bedingung ändert - und du keinen sauberen Zähler hast -, passt die while-Schleife besser. Das ist die nächste Seite.