Noch mehr Java gibts auf www.javahochzwei.de

Iterator

Ein Iterator (von lat. iterare „wiederholen“) ist eine Technik, um Datenstrukturen Element für Element durchgehen und diese ggf. bearbeiten, ausgeben o.Ä. zu können.

Bevor wir uns Code oder der Java API widmen wollen, möchte ich ein kleines Beispiel für einen Java-Iterator bringen. Stellen wir uns vor, wir haben einen Behälter -den wir „behälter“- nennen. Dieser ist mit Elementen -in unserem Fall einfachem Text (also Strings) gefüllt:

+---------------------behälter----------------------------+
|Dies | ist | ein | Iterator-Test | von | www.prog-blog.de|
|                                                         |
+---------------------------------------------------------+


(Die verschiedenen Farben sind hier von keiner Bedeutung!)

Ein Iterator geht diesen Behälter Element für Element durch. Hierzu benutzt er einen Zeiger, der jeweils immer auf das aktuelle Element zeigt:

+---------------------behälter----------------------------+
|Dies | ist | ein | Iterator-Test | von | www.prog-blog.de|
|^^^^                                                     |
+---------------------------------------------------------+

+---------------------behälter----------------------------+
|Dies | ist | ein | Iterator-Test | von | www.prog-blog.de|
|       ^^^                                               |
+---------------------------------------------------------+

+---------------------behälter----------------------------+
|Dies | ist | ein | Iterator-Test | von | www.prog-blog.de|
|             ^^^                                         |
+---------------------------------------------------------+

+---------------------behälter----------------------------+
|Dies | ist | ein | Iterator-Test | von | www.prog-blog.de|
|                   ^^^^^^^^^^^^^                         |
+---------------------------------------------------------+

+---------------------behälter----------------------------+
|Dies | ist | ein | Iterator-Test | von | www.prog-blog.de|
|                                   ^^^                   |
+---------------------------------------------------------+

+---------------------behälter----------------------------+
|Dies | ist | ein | Iterator-Test | von | www.prog-blog.de|
|                                         ^^^^^^^^^^^^^^^^|
+---------------------------------------------------------+

Deutet der Zeiger im jeweiligen Moment auf ein Objekt, so können wir dieses bearbeiten oder bspw. ausgeben lassen.

Fügen wir z.B. dem jeweiligen Element, auf das gerade der Zeiger deutet, ein „+“-Zeichen hinzu, sähe das so aus:

+----------------------behälter----------------------------+
|Dies+ | ist | ein | Iterator-Test | von | www.prog-blog.de|
|^^^^^                                                     |
+----------------------------------------------------------+

+------------..---------behälter----------------------------+
|Dies+ | ist+ | ein | Iterator-Test | von | www.prog-blog.de|
|        ^^^^                                               |
+------------------------..---------------------------------+

+------------------------behälter----------------------------+
|Dies+ | ist+ | ein+ | Iterator-Test | von | www.prog-blog.de|
|               ^^^^                                         |
+------------------------------------------------------------+

+-------------------------behälter----------------------------+
|Dies+ | ist+ | ein+ | Iterator-Test+ | von | www.prog-blog.de|
|                      ^^^^^^^^^^^^^^                         |
+-------------------------------------------------------------+

+--------------------------behälter----------------------------+
|Dies+ | ist+ | ein+ | Iterator-Test+ | von+ | www.prog-blog.de|
|                                       ^^^^                   |
+--------------------------------------------------------------+

+---------------------------behälter----------------------------+
|Dies+ | ist+ | ein+ | Iterator-Test+ | von+ | www.prog-blog.de+|
|                                               ^^^^^^^^^^^^^^^^|
+---------------------------------------------------------------+

Soweit, so gut!
Ein Iterator ist also eine Art Zeiger, der durch eine Datenstruktur wandert und dabei mal auf jedes Element gezeigt hat.

Wollen wir uns nun anschauen, was die Java API zum Thema Iteratoren sagt. Das wichtigste sind die Methoden, die uns Entwicklern zur Verfügung stehen:

Es gibt nur drei Stück: boolean hasNext(), Object next(), void remove():

  • boolean hasNext(): gibt ein true zurück, wenn der Zeiger noch nicht an das Ende unserer Datenstruktur zeigt und es somit noch ein nächstes Element gibt!
  • Object next(): gibt uns das Element züruck, auf das der Zeiger zeigt und setzt diesen weiter
  • void remove(): löscht das Element aus unserer Datenstruktur, auf das der Zeiger gerade deutet.

Wir erstellen uns jetzt erstmal einen Behälter, in diesem Fall ein Vector -der nur Objekte vom Typ String enthalten kann-, daher das Vector:

package iterator;

import java.util.Vector;

/**
 * @author Armin
 * @since 18.09.2012
 *
 * info@prog-blog.de
 * www.prog-blog.de 
 */
public class IteratorTest {

	public static void main(String[] args) {

		Vector<String> behälter = new Vector<String>();

		behälter.add("Dies");
		behälter.add("ist");
		behälter.add("ein");
		behälter.add("Iterator-Test");
		behälter.add("von");
		behälter.add("www.prog-blog.de");
	}
}

Wollen wir diesen Behälter nun mit Hilfe eines Iterators durchgehen, benutzen wir die Methoden hasNext() und next():

package iterator;

import java.util.Iterator;
import java.util.Vector;

/**
 * @author Armin
 * @since 18.09.2012
 *
 * info@prog-blog.de
 * www.prog-blog.de 
 */
public class IteratorTest {

	public static void main(String[] args) {

		Vector<String> behälter = new Vector<String>();

		behälter.add("Dies");
		behälter.add("ist");
		behälter.add("ein");
		behälter.add("Iterator-Test");
		behälter.add("von");
		behälter.add("www.prog-blog.de");

		Iterator<String> iterator = behälter.iterator();

		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

Die Ausgabe ist folgende:

Dies
ist
ein
Iterator-Test
von
www.prog-blog.de

Was haben wir nun gemacht? Viele Datenstrukturen (Vector, ArrayList, LinkedList etc.) stellen dem Entwickler einen Iterator zur Verfügung. Diesen bekommen wir mit Hilfe der Methode .iterator():

Iterator<String> iterator = behälter.iterator();

„Iterator“ besagt, dass wir einen Iterator haben, der mit Strings arbeitet. Macht ja auch Sinn, da wir unseren Vector behälter ja mit „Vectorbehälter“ initialisiert haben. Dies bedeutet übrigens, dass man dem Vector nur Objekte vom Typ String hinzufügen kann, nur mal so nebenbei. ;)

Okay. Mit Hilfe unseres Iterator-Objekts iterator und den beiden Methoden können wir jetzt den ganzen Behälter durchgehen. Mit Hilfe von

while (iterator.hasNext())

wird die Schleife so oft durchlaufen, bis es kein nächstes Element mehr gibt!

iterator.next();

gibt jeweils das Element zurück, auf das der Zeiger zeigt. In unserem Beispiel lassen wir uns dies auf der Konsole mit Hilfe von

System.out.println(iterator.next());

einfach ausgeben.

Als weitere, kompaktere Möglichkeit kann man für das Durchlaufen auch eine for-Schleife benutzen. Der Effekt ist aber der gleiche!

		for (Iterator<String> iterator2 = behälter.iterator(); iterator2.hasNext();) {
			System.out.println(iterator2.next());
		}

Quelltext herunterladen:

  iterator.rar (489 bytes, 60 hits)

Wollt ihr einen eigenen Iterator schreiben? Dann schaut Euch diesen Post mal an!

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.