Java for-each-Schleife: Syntax, Beispiele und Fallstricke

Wenn der Index nur im Weg ist

Eine gezählte for-Schleife gibt dir einen Zähler, eine Bedingung und einen Aktualisierungsschritt. Aber sehr oft interessiert dich die Position eines Elements gar nicht – du willst einfach mit jedem etwas tun, der Reihe nach, von Anfang bis Ende. Dafür einen Index zu verwalten ist überflüssige Arbeit, und genau dort schleichen sich Off-by-one-Fehler ein.

Die for-each-Schleife (Java nennt sie das erweiterte for) lässt den Zähler komplett weg. Du benennst eine Variable, richtest sie auf eine Collection, und die Schleife reicht dir jedes Element der Reihe nach.

Grundlegende Syntax

Die Form lautet for (Typ element : collection). Lies den Doppelpunkt als das Wort „in":

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 100};

        for (int score : scores) {
            System.out.println("Score: " + score);
        }
    }
}

Kein i, kein scores.length, kein scores[i]. Bei jedem Durchlauf ist score das nächste Element. Die Schleife läuft einmal pro Element und stoppt automatisch, wenn keines mehr da ist – du kannst weder über das Ende hinauslaufen noch ein Element zu früh beginnen.

Über eine Liste iterieren

Dieselbe Schleife funktioniert mit allem Iterierbaren, was List, Set und die übrigen Collection-Typen einschließt. Der Elementtyp steht vor dem Variablennamen:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang + " has " + lang.length() + " letters");
        }
    }
}

Beachte, dass du nicht wissen oder dich kümmern musstest, ob langs von einem Array, einer verketteten Liste oder etwas anderem gestützt wird – for-each funktioniert bei allen gleich. Das ist seine eigentliche Stärke: eine lesbare Syntax für jede Collection.

var erspart dir den Typnamen

Wenn der Elementtyp lang oder offensichtlich ist, lässt var den Compiler ihn ableiten, damit du dich nicht wiederholst:

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.of("Ann", 30, "Bo", 25);

        for (var entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Ohne var wäre diese Schleifenvariable der Zungenbrecher Map.Entry<String, Integer>. var hält das lesbar, und der Typ wird zur Kompilierzeit weiterhin vollständig geprüft – das ist kein lockerer, dynamischer Typ.

Der Modifikations-Fallstrick

Hier ist die Regel, über die jeder stolpert: Du kannst zu einer Collection nichts hinzufügen oder daraus entfernen, während eine for-each-Schleife sie durchläuft. Tust du es doch, wirft sie eine ConcurrentModificationException:

List<String> items = new ArrayList<>(List.of("a", "b", "c"));

for (String item : items) {
    if (item.equals("b")) {
        items.remove(item);   // wirft ConcurrentModificationException
    }
}

Die Schleife merkt, dass sich die Liste unter ihr verändert hat, und bricht ab, statt Elemente still zu überspringen oder zu wiederholen. Um sicher zu entfernen, steig auf einen expliziten Iterator herab, der ein remove() besitzt, von dem die Schleife weiß:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("a", "b", "c"));

        Iterator<String> it = items.iterator();
        while (it.hasNext()) {
            if (it.next().equals("b")) {
                it.remove();   // sicher
            }
        }

        System.out.println(items);   // [a, c]
    }
}

Eine gängige Abkürzung ist items.removeIf(item -> item.equals("b")), das dasselbe in einer Zeile erledigt.

Nur lesen, nicht neu zuweisen

Eine weitere subtile Grenze: Der Schleifenvariable etwas zuzuweisen ändert nur die lokale Kopie, nicht die Collection. Das überrascht alle, die aus Sprachen kommen, in denen die Schleifenvariable eine lebendige Referenz ist:

public class Main {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};

        for (int n : nums) {
            n = n * 10;   // ändert die Kopie, nicht das Array
        }

        System.out.println(nums[0]);   // immer noch 1
    }
}

Wenn du ins Array zurückschreiben musst, brauchst du den Index – und das bedeutet die klassische gezählte for-Schleife: for (int i = 0; i < nums.length; i++) nums[i] = nums[i] * 10;. Bei Objekt-Elementen kannst du das Objekt, auf das die Variable zeigt, verändern (etwa einen Setter aufrufen), aber du kannst es nicht in der Collection ersetzen.

break und continue funktionieren weiterhin

Ein for-each ist eine echte Schleife, also verhalten sich break und continue genauso wie überall sonst – break verlässt die Schleife, continue springt zum nächsten Element:

public class Main {
    public static void main(String[] args) {
        String[] words = {"keep", "skip", "keep", "stop", "never"};

        for (String w : words) {
            if (w.equals("skip")) continue;   // dieses überspringen
            if (w.equals("stop")) break;      // ganz aufhören
            System.out.println(w);
        }
    }
}

Das gibt keep und dann keep aus – es überspringt "skip" und hält bei "stop", bevor es "never" erreicht. Du bist also nicht gezwungen, jedes Element zu besuchen; du gibst nur den Index gegen saubereren Code auf.

Als Nächstes: Arrays

Du hast jetzt mehrmals über Arrays iteriert, ohne dich damit aufzuhalten, was sie eigentlich sind – indexierte Container fester Größe mit diesem .length-Feld. Die nächste Seite geht zurück zum Anfang und behandelt Arrays ordentlich: wie man sie deklariert, mit welchen Standardwerten sie beginnen und worin sich ihre feste Größe von einer wachsenden ArrayList unterscheidet.