Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 15 - Collections II

## 15.3 Iteratoren

- 15.3 Iteratoren
  - 15.3.1 Das Interface Iterator
  - 15.3.2 Das Interface ListIterator

### 15.3.1 Das Interface Iterator

Auf die Collections der Prä-1.2-JDKs konnte mit Hilfe des `Enumeration`-Interfaces und seiner beiden Methoden `hasMoreElements` und `nextElement` zugegriffen werden. Da Objekte, die dem Durchlaufen von Collections dienen, überall in der Informatik als Iteratoren bezeichnet werden, wurde die Namensgebung des Interfaces und seiner Methoden vielfach kritisiert. Die Designer der Collections der Version 1.2 haben sich nun dem allgemeinen Sprachgebrauch angepaßt und das Interface zum Durchlaufen der Elemente einer Collection als `Iterator` bezeichnet und mit folgenden Methoden ausgestattet:

    boolean hasNext()

    Object next()

    void remove()
| java.util.Iterator

`hasNext` gibt genau dann `true` zurück, wenn der Iterator mindestens ein weiteres Element enthält. `next` liefert das nächste Element bzw. löst eine Ausnahme des Typs `NoSuchElementException` aus, wenn es keine weiteren Elemente gibt. Wie beim `Enumeration`-Interface ist der Rückgabewert als `Object` deklariert und muß daher auf das passende Object gecastet werden. Als neues Feature (gegenüber einer `Enumeration`) bietet ein `Iterator` die Möglichkeit, die Collection während der Abfrage zu ändern, indem das zuletzt geholte Element mit der Methode `remove` gelöscht wird. Bei allen Collections, die das Interface `Collection` implementieren, kann ein Iterator zum Durchlaufen aller Elemente mit der Methode `iterator` beschafft werden.

|  |  |  | Dies ist auch gleichzeitig die einzige erlaubte Möglichkeit, die Collection während der Verwendung eines Iterators zu ändern. Alle direkt ändernden Zugriffe auf die Collection machen das weitere Verhalten des Iterators undefiniert. |  |
Warnung

Wir wollen uns die Benutzung eines Iterators an einem Beispiel ansehen:

    001 /* Listing1502.java */
    002
    003 import java.util.*;
    004
    005 public class Listing1502
    006 {
    007   public static void main(String[] args)
    008   {
    009     //Füllen der Liste
    010     ArrayList list = new ArrayList();
    011     for (int i = 1; i <= 20; ++i) {
    012       list.add("" + i);
    013     }
    014     //Löschen von Elementen über Iterator
    015     Iterator it = list.iterator();
    016     while (it.hasNext()) {
    017       String s = (String) it.next();
    018       if (s.startsWith("1")) {
    019         it.remove();
    020       }
    021     }
    022     //Ausgeben der verbleibenden Elemente
    023     it = list.iterator();
    024     while (it.hasNext()) {
    025       System.out.println((String) it.next());
    026     }
    027   }
    028 }
| Listing1502.java

Listing 15.2: Zugriff auf eine Collection mit einem Iterator

Das Programm erzeugt zunächst eine Liste mit den Elementen "1", "2", ..., "20". Anschließend wird durch Aufruf von `iterator` ein Iterator über alle Elemente der Liste beschafft. Mit seiner Hilfe werden alle Elemente der Liste durchlaufen und diejenigen, die mit "1" anfangen, gelöscht. Der zweite Durchlauf durch die Liste zeigt dann nur noch die übriggebliebenen Elemente an:

    2
    3
    4
    5
    6
    7
    8
    9
    20

### 15.3.2 Das Interface ListIterator

Neben dem `Iterator`-Interface gibt es das daraus abgeleitete Interface `ListIterator`. Es steht nur bei Collections des Typs `List` (und daraus abgeleiteten Klassen) zur Verfügung und bietet zusätzlich die Möglichkeit, die Liste in beiden Richtungen zu durchlaufen, auf den Index des nächsten oder vorigen Elements zuzugreifen, das aktuelle Element zu verändern und ein neues Element hinzuzufügen:

    boolean hasPrevious()
    Object previous()

    int nextIndex()
    int previousIndex()

    void add(Object o)
    void set(Object o)
| java.util.ListIterator

Mit `hasPrevious` kann bestimmt werden, ob es vor der aktuellen Position ein weiteres Element gibt; der Zugriff darauf würde mit `previous` erfolgen. Die Methoden `nextIndex` und `previousIndex` liefern den Index des nächsten bzw. vorigen Elements des Iterators. Wird `previousIndex` am Anfang des Iterators aufgerufen, ist sein Rückgabewert -1. Wird `nextIndex` am Ende aufgerufen, liefert es `size()` als Rückgabewert. Mit `add` kann ein neues Element an der Stelle in die Liste eingefügt werden, die unmittelbar vor dem nächsten Element des Iterators liegt. `set` erlaubt es, das durch den letzten Aufruf von `next` bzw. `previous` beschaffte Element zu ersetzen.

|  | Ebenso wie beim Interface `Collection` sind die ändernden Methoden der Iteratoren optional. Falls ein Iterator eine dieser Methoden nicht zur Verfügung stellen will, löst er bei ihrem Aufruf eine Ausnahme des Typs `UnsupportedOperationException` aus. Das gilt für die Methoden `add`, `set` und `remove`. |  |
Hinweis

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de