16.3 Iteratoren

• 16.3 Iteratoren
  • 16.3.1 Das Interface Iterator
  • 16.3.2 Das Interface ListIterator

16.3.1 Das Interface Iterator

Auf die Collections der Prä-1.2-JDKs konnte mit Hilfe des Enumeration-Interface 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 Interface und seiner Methoden vielfach kritisiert. Die Designer der Collections der Version 1.2 haben sich nun dem allgemeinen Sprachgebrauch angepasst 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

Ein solches Iterator-Objekt kann über die Methode iterator für jede Collection des Frameworks erzeugt werden. Hierfür wurde das Interface java.lang.Iterable definiert, welches auch von jeder Collection implementiert wird.

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 muss 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.

Die Methode remove ist die einzig 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 /* Listing1602.java */ 002 003 import java.util.*; 004 005 public class Listing1602 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 }

Listing1602.java

Listing 16.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 übrig gebliebenen Elemente an:

2
3
4
5
6
7
8
9
20

Seit der J2SE 5.0 gibt es eine Erweiterung der for-Schleife, mit der Collection-Klassen noch einfacher durchlaufen werden können. Diese als foreach-Schleife bezeichnete Variante wird in Abschnitt 7.3.3 ausführlich erläutert. Ein Beispiel dazu findet sich auch in Listing 7.7.

16.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