ArrayList: Listen ausgeben

Lösung geprüft

Die Aufgabe der heutigen Stunde ist das sequenzielle Ausgeben von Listen! Wir bauen eine Liste mit den Zahlen 10, 20, 30 bis 1000 und geben sie auf zwei Arten aus. Die Aufgabe ist klein, zeigt aber genau die drei Wege, eine Liste zu durchlaufen.

Die Aufgabenstellung lautet

1. Erstellen Sie mit einer for-Schleife eine ArrayList, die die Zahlen 10, 20, 30 … bis 1000 enthält.
2. Lassen Sie sich alle Elemente ausgeben,
1. einmal mit einer foreach-Schleife,
2. einmal mit dem ListIterator

Lösungsprozess der Aufgabe

ListenAusgabe.java

/* meininfokurs.cmrg.site */

/**
 *
 * Listen sequenziell ausgeben - foreach und ListIterator
 *
 * @version 1.0 vom 09.09.2025
 * @meininfokurs.cmrg.site
 */

import java.util.ArrayList;
import java.util.ListIterator;

public class ListenAusgabe {

    public static void main(String[] args) {

        // 1. Die Liste mit einer for-Schleife fuellen: 10, 20, 30 ... 1000
        ArrayList<Integer> liste = new ArrayList<Integer>();
        for (int i = 10; i <= 1000; i += 10) {
            liste.add(i);
        }

        // 2.1 Ausgabe mit der foreach-Schleife
        System.out.println("--- foreach ---");
        for (int zahl : liste) {
            System.out.println(zahl);
        }

        // 2.2 Ausgabe mit dem ListIterator
        System.out.println("--- ListIterator ---");
        ListIterator<Integer> laeufer = liste.listIterator();
        while (laeufer.hasNext()) {
            System.out.println(laeufer.next());
        }

    } // end of main

} // end of class ListenAusgabe

Die Liste füllen

for (int i = 10; i <= 1000; i += 10) {
    liste.add(i);
}

Drei Stellen, an denen man danebenliegen kann. Der Startwert ist 10, nicht 0 – die Aufgabe will bei 10 anfangen. Die Bedingung ist <= 1000 und nicht < 1000, sonst fehlt die 1000 am Ende. Und die Schrittweite ist i += 10 statt i++. Am Ende sind es 100 Zahlen.

Die foreach-Schleife

for (int zahl : liste) {
    System.out.println(zahl);
}

Gelesen: „für jede Zahl in liste". Man braucht keinen Index, keine Abbruchbedingung, kein Hochzählen – und kann damit auch keinen Off-by-one-Fehler bauen. Deshalb ist das der übliche Weg, wenn man einfach alles durchgehen will.

Der Haken: du hast in der Schleife nur eine Kopie des Wertes. zahl = 5; ändert die Liste nicht. Willst du die Elemente verändern, brauchst du die normale for-Schleife mit Index und liste.set(i, ...).

Der ListIterator

ListIterator<Integer> laeufer = liste.listIterator();
while (laeufer.hasNext()) {
    System.out.println(laeufer.next());
}

Der Iterator ist ein Zeiger, der zwischen den Elementen sitzt und Schritt für Schritt weiterrückt. Zwei Methoden reichen: hasNext() fragt, ob noch was kommt, und next() liefert das nächste Element und rückt weiter.

Wichtig: next() in einem Durchlauf nur einmal aufrufen. Wer System.out.println(laeufer.next() + " und " + laeufer.next()); schreibt, überspringt bei jedem Durchlauf ein Element und wundert sich.

Warum gibt es das, wenn foreach doch kürzer ist? Weil der Iterator etwas kann, was foreach nicht kann: während des Durchlaufens die Liste verändern. Mit laeufer.remove() darfst du das gerade gelieferte Element rauswerfen. Versuchst du dasselbe in einer foreach-Schleife mit liste.remove(...), fliegt dir eine ConcurrentModificationException um die Ohren. Der ListIterator kann außerdem rückwärts, über hasPrevious() und previous().

Die drei Wege im Überblick

Weg	Wann man ihn nimmt
`for` mit Index	Wenn du den Index brauchst oder Elemente ändern willst
`foreach`	Wenn du nur alles einmal durchgehen willst – der Normalfall
`ListIterator`	Wenn du beim Durchlaufen löschen oder rückwärts gehen willst

Und so sieht es aus

Konsole

--- foreach ---
10
20
30
...
1000
--- ListIterator ---
10
20
30
...
1000

Beide Ausgaben sind identisch, das ist ja auch der Punkt der Aufgabe. Es sind hundert Zeilen pro Durchlauf, da scrollt die Konsole ein bisschen.