CodeGym /Kurse /JAVA 25 SELF /Iterable und Iterator: Sammlungen durchlaufen

Iterable und Iterator: Sammlungen durchlaufen

JAVA 25 SELF
Level 27, Lektion 1
Verfügbar

1. Das Interface Iterable

In Java implementieren fast alle Sammlungen (außer Map) das Interface Iterable. Das bedeutet, dass man sie sequentiell – Element für Element – durchlaufen kann, ohne sich in Details der internen Struktur zu verlieren. Für Entwickler wirkt das wie: „Die Sammlung hat einen eingebauten Weg, über alle Elemente zu gehen.“

Das Interface Iterable definiert genau eine Methode:

Iterator<E> iterator();

Die Methode iterator() gibt ein Objekt vom Typ Iterator zurück – einen „Assistenten“, der weiß, wie man die Sammlung Schritt für Schritt durchläuft. Dadurch funktioniert die gewohnte for-each-Schleife:

for (ElementType e : collection) {
    // ...
}

– hinter den Kulissen steckt genau dieser Iterator. Ein zusätzlicher Pluspunkt: Mit ihm kann man während des Durchlaufs Elemente sicher mit remove() löschen. Versucht man das mit einer normalen Schleife, fängt man leicht eine ConcurrentModificationException.

2. Das Interface Iterator

Iterator ist so etwas wie ein „Kurier“, der Ihre Sammlung entlanggeht, nichts auslässt und die vorgegebene Iterationsreihenfolge einhält.

Methode Beschreibung
boolean hasNext()
Gibt es weitere Elemente zum Durchlaufen?
E next()
Gibt das nächste Element zurück und geht zu ihm über
void remove()
Löscht das aktuelle Element sicher, ohne Fehler

Beispiel: Sammlung mit Iterator durchlaufen

import java.util.*;

public class IteratorDemo {
    public static void main(String[] args) {
        List<String> tasks = new ArrayList<>();
        tasks.add("Katze streicheln");
        tasks.add("Hausaufgaben erledigen");
        tasks.add("Serie schauen");

        Iterator<String> it = tasks.iterator();
        while (it.hasNext()) {
            String task = it.next();
            System.out.println("Aufgabe: " + task);
        }
    }
}

Was passiert hier?

  • Wir holen den Iterator über tasks.iterator().
  • Solange es ein nächstes Element gibt (hasNext() liefert true), holen wir es via next() und geben es aus.
  • Der Iterator kümmert sich selbst um die Reihenfolge – Sie müssen nicht wissen, wie die Sammlung intern die Elemente speichert.

3. Warum braucht man einen Iterator, wenn es Schleifen gibt?

Mit Iterator kann man jede Sammlung durchlaufen, selbst ohne Indizes (zum Beispiel Set). Das ist ein universeller Ansatz, der nicht vom konkreten Sammlungstyp abhängt.

Sicheres Löschen von Elementen

Eine häufige Aufgabe: eine Sammlung durchlaufen und dabei bestimmte Elemente löschen. Tut man das mit for-each, kann ein Fehler auftreten:

for (String task : tasks) {
    if (task.contains("Katze")) {
        tasks.remove(task); // Boom! ConcurrentModificationException
    }
}

Warum passiert das? Die Sammlung erwartet nicht, dass ihre Struktur direkt während eines vom Iterator initiierten Durchlaufs verändert wird.

Der richtige Weg:

Iterator<String> it = tasks.iterator();
while (it.hasNext()) {
    String task = it.next();
    if (task.contains("Katze")) {
        it.remove(); // Alles läuft reibungslos!
    }
}

Warum nicht einfach Indizes verwenden?

Weil nicht alle Sammlungen Indizes haben. Zum Beispiel haben HashSet oder TreeSet kein Konzept eines „fünften Elements“. Iterator funktioniert immer – darin liegt seine Stärke.

4. Details zu for-each

Die erweiterte for-Schleife (for-each) gibt es seit Java 5. Im Grunde ist das syntaktischer Zucker, der das Durchlaufen so einfach wie möglich macht:

for (String task : tasks) {
    System.out.println("Aufgabe: " + task);
}

Unter der Haube ruft der Compiler iterator() auf, prüft die Elemente mit hasNext() und holt sie mit next(). Das liest sich wörtlich wie ein Satz in Umgangssprache: „für jede Aufgabe aus der Liste“.

Wann ist for-each ungeeignet?

  • Sie müssen während des Durchlaufs Elemente löschen (for-each erlaubt keinen direkten Aufruf von remove()).
  • Sie brauchen Zugriff auf den Index, um z. B. ein Element an einer Position zu ersetzen.
  • Sie arbeiten mit Map – dort gibt es „Schlüssel–Wert“-Paare; für den Durchlauf ist eigene Logik nötig.

5. Map durchlaufen: Tipps und Feinheiten

Das Interface Map implementiert Iterable nicht direkt, da es sich um „Schlüssel–Wert“-Paare handelt. Dennoch stellt Map praktische Sichten für den Durchlauf bereit.

Über die Schlüssel iterieren

Map<String, String> users = new HashMap<>();
users.put("john", "john@example.com");
users.put("peter", "peter@gmail.com");

for (String login : users.keySet()) {
    System.out.println("Login: " + login);
}

Über die Werte iterieren

for (String email : users.values()) {
    System.out.println("Email: " + email);
}

Über Paare (Schlüssel–Wert) iterieren

Die universellste Methode – die Iteration über entrySet():

for (Map.Entry<String, String> entry : users.entrySet()) {
    System.out.println("Login: " + entry.getKey() + ", Email: " + entry.getValue());
}

Interessante Tatsache: Entry ist ein inneres Interface von Map mit den Methoden getKey() und getValue(). So bekommen Sie beide Teile des Paares sofort.

Iteration per Iterator

Iterator<Map.Entry<String, String>> it = users.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry<String, String> entry = it.next();
    // Man kann sogar sicher ein Element löschen:
    if (entry.getKey().startsWith("v")) {
        it.remove();
    }
}

6. Praxisbeispiele: Wie das Durchlaufen von Sammlungen in Anwendungen hilft

Beispiel: Alle Aufgaben eines Benutzers ausgeben

List<String> tasks = new ArrayList<>();
tasks.add("Hausaufgaben erledigen");
tasks.add("Katze streicheln");
tasks.add("Serie schauen");

System.out.println("Ihre Aufgaben für heute:");
for (String task : tasks) {
    System.out.println("- " + task);
}

Nun löschen wir alle Aufgaben, die das Wort "Katze" enthalten:

Iterator<String> it = tasks.iterator();
while (it.hasNext()) {
    String task = it.next();
    if (task.contains("Katze")) {
        it.remove();
    }
}
System.out.println("Verbleibende Aufgaben:");
for (String task : tasks) {
    System.out.println("- " + task);
}

Beispiel: Einzigartige Logins per Set durchlaufen

Set<String> logins = new HashSet<>();
logins.add("john");
logins.add("peter");
logins.add("mary");

for (String login : logins) {
    System.out.println("Benutzer: " + login);
}

Beachten Sie: Die Ausgabereihenfolge bei Set kann beliebig sein!

Beispiel: Map durchlaufen, um Benutzer anzuzeigen

Map<String, String> users = new HashMap<>();
users.put("john", "john@example.com");
users.put("peter", "peter@gmail.com");

for (Map.Entry<String, String> entry : users.entrySet()) {
    System.out.println("Login: " + entry.getKey() + ", Email: " + entry.getValue());
}

7. Iterator.remove(): sicheres Löschen von Elementen

Einer der häufigsten Fehler von Einsteigern ist der Versuch, während eines for-each-Durchlaufs Elemente zu löschen. Der Iterator löst dieses Problem mit remove().

Wie funktioniert das?

  • Beim Aufruf von it.remove() wird das aktuelle Element gelöscht – jenes, das der letzte next()-Aufruf geliefert hat.
  • Das ist sicher: Die Sammlung wirft keine ConcurrentModificationException.

Beispiel:

List<Integer> numbers = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    int n = it.next();
    if (n % 2 == 0) {
        it.remove(); // Wir entfernen alle geraden Zahlen
    }
}
System.out.println(numbers); // [1, 3, 5]

Schema des Durchlaufens einer Sammlung

+---------+     +---------+     +---------+
| Element | --> | Element | --> | Element | ...
+---------+     +---------+     +---------+
     ^               ^
     |               |
   next()         next()

Der Iterator „schreitet“ durch die Elemente, bis hasNext() false zurückgibt.

9. Typische Fehler beim Arbeiten mit Iterator und beim Durchlaufen von Sammlungen

Fehler №1: Änderung der Sammlung während des for-each-Durchlaufs.
Der Versuch, ein Element direkt in for-each zu löschen, führt zu ConcurrentModificationException:

for (String task : tasks) {
    if (task.contains("Katze")) {
        tasks.remove(task); // Boom! ConcurrentModificationException
    }
}

Verwenden Sie Iterator und dessen remove().

Fehler №2: remove() vor next() aufrufen.
Zuerst muss man das aktuelle Element über next() holen, sonst weiß der Iterator nicht, was er löschen soll.

Iterator<String> it = tasks.iterator();
it.remove(); // Fehler! Zuerst ist next() erforderlich

Fehler №3: Versuch, eine Map direkt in for-each zu durchlaufen.
Map implementiert Iterable nicht direkt – verwenden Sie keySet(), values() oder entrySet().

Map<String, String> users = new HashMap<>();
// for (String entry : users) { ... } // Fehler: so geht es nicht
for (Map.Entry<String, String> e : users.entrySet()) {
    // richtig
}

Fehler №4: Änderung der Sammlung außerhalb des Iterators während des Iterator-Durchlaufs.
Während des Durchlaufs Elemente nur über it.remove() löschen, nicht über Methoden der Sammlung.

Iterator<String> it = tasks.iterator();
while (it.hasNext()) {
    String task = it.next();
    if (task.contains("Katze")) {
        tasks.remove(task); // Fehler! Es muss it.remove() sein
    }
}
1
Aufgabe
JAVA 25 SELF, Level 27, Lektion 1
Gesperrt
Wörterbuch außerirdischer Sprachen 👽
Wörterbuch außerirdischer Sprachen 👽
1
Aufgabe
JAVA 25 SELF, Level 27, Lektion 1
Gesperrt
Verwaltung der Technologieliste für das Projekt 🛠️
Verwaltung der Technologieliste für das Projekt 🛠️
Kommentare
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION