0Pricing
Java Academy · Lektion

Die Verträge von Iterable und Iterator

Verstehen Sie die Schnittstellen Iterable und Iterator sowie die interne Funktionsweise von for-each-Schleifen.

Die Verträge von Iterable und Iterator ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Iterable und Iterator

Iterable<T> und Iterator<T> sind die Interfaces, die Javas for-each-Schleife ermöglichen. Wenn Sie sie verstehen, können Sie eigene Datenstrukturen erstellen, die in Schleifen verwendet werden können.

Das Iterable-Interface

Iterable<T> besitzt eine Methode: iterator(), die einen Iterator<T> zurückgibt. Jede Klasse, die Iterable implementiert, kann in einer for-each-Schleife verwendet werden.

// java.lang.Iterable<T>
interface Iterable<T> {
    Iterator<T> iterator();
    // default: forEach, spliterator (Java 8+)
}

// Any class implementing Iterable<T> works in for-each:
class Range implements Iterable<Integer> {
    private final int start, end;
    Range(int start, int end) { this.start = start; this.end = end; }

    public Iterator<Integer> iterator() {
        return new RangeIterator(); // defined separately
    }
}

Das Iterator-Interface

Iterator<T> besitzt drei Methoden: hasNext(), next() und die optionale Methode remove().

// java.util.Iterator<T>
interface Iterator<T> {
    boolean hasNext(); // true if more elements
    T next();          // returns next element, advances cursor
    default void remove() { throw new UnsupportedOperationException(); }
}

// How for-each desugars internally:
// for (T item : iterable) { use(item); }
// becomes:
Iterator<T> it = iterable.iterator();
while (it.hasNext()) {
    T item = it.next();
    // use(item)
}

Auflösung der for-each-Schleife

Die for-each-Schleife ist syntaktischer Zucker für das Iterable/Iterator-Muster. Wenn Sie dies verstehen, können Sie eigene Iterables korrekt implementieren.

List<String> names = List.of("Alice", "Bob", "Charlie");

// For-each (readable way)
for (String name : names) {
    System.out.println(name);
}

// Equivalent explicit form
Iterator<String> it = names.iterator();
while (it.hasNext()) {
    String name = it.next();
    System.out.println(name);
}

Cursor-Zustand eines Iterators

Ein Iterator verwaltet einen Cursor – eine Position in der Sequenz. Der Aufruf von next() bewegt den Cursor weiter. Sobald der Iterator erschöpft ist, kann er nicht zurückgesetzt werden.

List<Integer> nums = List.of(1, 2, 3);
Iterator<Integer> it = nums.iterator();

System.out.println(it.hasNext()); // true
System.out.println(it.next());    // 1
System.out.println(it.next());    // 2
System.out.println(it.next());    // 3
System.out.println(it.hasNext()); // false

try {
    it.next(); // NoSuchElementException
} catch (java.util.NoSuchElementException e) {
    System.out.println("No more elements!");
}

ConcurrentModificationException

Wenn Sie eine Collection während der Iteration mit einem expliziten Iterator ändern (außer durch Iterator.remove()), wird ConcurrentModificationException ausgelöst.

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

// BAD: modifying collection during for-each
try {
    for (String s : list) {
        if ("b".equals(s)) list.remove(s); // ConcurrentModificationException!
    }
} catch (java.util.ConcurrentModificationException e) {
    System.out.println("Cannot modify during iteration!");
}

// GOOD: use Iterator.remove()
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if ("b".equals(it.next())) it.remove(); // safe
}
System.out.println(list); // [a, c, d]

Mehrere Iteratoren

Jeder Aufruf von iterator() gibt einen neuen, unabhängigen Iterator zurück. Mehrere Iteratoren können gleichzeitig für dieselbe Collection aktiv sein.

List<Integer> nums = List.of(1, 2, 3);

Iterator<Integer> a = nums.iterator();
Iterator<Integer> b = nums.iterator();

System.out.println(a.next()); // 1
System.out.println(b.next()); // 1 (independent cursor)
System.out.println(a.next()); // 2
System.out.println(b.next()); // 2

Iterable oder Iterator

Der entscheidende Unterschied:

  • Iterable: eine Quelle, die Iteratoren erzeugen kann – sie kann mehrfach durchlaufen werden
  • Iterator: ein Cursor über eine Sequenz – einmalig verwendbar und zustandsbehaftet
// Iterable: reusable
List<String> list = List.of("x", "y");
for (String s : list) {} // OK
for (String s : list) {} // OK again — new iterator each time

// Iterator: single-use
Iterator<String> it = list.iterator();
while (it.hasNext()) it.next();
// for (String s : it) {} // compile error — Iterator is not Iterable!

Praxis: Benutzerdefiniertes Iterable für Dateizeilen

Ein Dateileser, der Iterable implementiert und dadurch eine for-each-Schleife über seine Zeilen ermöglicht.

import java.io.*;
import java.util.*;

class FileLines implements Iterable<String>, Closeable {
    private final BufferedReader reader;

    FileLines(String path) throws IOException {
        this.reader = new BufferedReader(new FileReader(path));
    }

    public Iterator<String> iterator() {
        return new Iterator<>() {
            private String nextLine = readNext();

            private String readNext() {
                try { return reader.readLine(); }
                catch (IOException e) { return null; }
            }

            public boolean hasNext() { return nextLine != null; }
            public String next() {
                String curr = nextLine;
                nextLine = readNext();
                return curr;
            }
        };
    }

    public void close() throws IOException { reader.close(); }
}

Standardmethode forEach

Java 8 fügte Iterable die Standardmethode forEach(Consumer) hinzu. Sie ist eine praktische Alternative zum Schreiben expliziter Schleifen.

List<String> cities = List.of("New York", "London", "Tokyo");

// for-each loop
for (String city : cities) System.out.println(city);

// forEach with lambda
cities.forEach(city -> System.out.println(city));

// forEach with method reference (most concise)
cities.forEach(System.out::println);

// For transforming: use stream
cities.stream()
    .map(String::toUpperCase)
    .forEach(System.out::println);

Das Iterator-Muster in der Praxis

Zusammenfassung, wann Sie Iterable/Iterator implementieren sollten:

  • Benutzerdefinierte Datenstrukturen (Baum, Graph, verkettete Liste)
  • Faule Sequenzen, die Elemente bei Bedarf erzeugen
  • Ressourcenbasierte Sequenzen (Dateizeilen, Datenbank-Cursor, Nachrichtenwarteschlange)

Kurztest

Welche Exception wird ausgelöst, wenn Sie eine Collection während der Iteration mit einer for-each-Schleife ändern?

Zusammenfassung: Die Verträge von Iterable und Iterator

Die wichtigsten Erkenntnisse:

  • Iterable<T> besitzt eine Methode: iterator() – ermöglicht die Verwendung in for-each-Schleifen
  • Iterator<T> besitzt hasNext(), next() und die optionale Methode remove()
  • Die for-each-Schleife ist syntaktischer Zucker für das Iterable/Iterator-Muster
  • Rufen Sie iterator() mehrfach auf, um unabhängige, neue Cursor zu erhalten
  • Ändern Sie niemals eine Collection während einer for-each-Schleife – verwenden Sie stattdessen Iterator.remove()
  • Implementieren Sie Iterable für eigene Datenstrukturen, damit diese in for-each-Schleifen verwendet werden können

Häufig gestellte Fragen

Ist die Lektion „Die Verträge von Iterable und Iterator“ kostenlos?

Ja — der vollständige Text von „Die Verträge von Iterable und Iterator“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Die Verträge von Iterable und Iterator“?

Verstehen Sie die Schnittstellen Iterable und Iterator sowie die interne Funktionsweise von for-each-Schleifen. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Die Verträge von Iterable und Iterator“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Die Verträge von Iterable und Iterator
  2. Einen eigenen Iterator implementieren
  3. ListIterator und bidirektionales Durchlaufen
  4. Fail-Fast- vs. Fail-Safe-Iteratoren
← Zurück zu Java Academy