Collections Iterator<E>

[Wang]

Hallo,

ich lese mich gerade in Collections ein und eine Passage gibt mir etwas zu denken:

Die Methoden hasNext() und next() des Iterators sind in der Schnittstelle Iterator<E> deklariert. Jede Collection-Klasse hat ihre eigene Iterator-Klasse, welche diese Schnittstelle implementiert.

Wenn man das wörtlich nimmt, bedeutet es doch, dass z.B. zu ArrayList, PriorityQueue, HashSet, etc. eine Iterator<E>-Klasse gibt...?
In der API habe ich solche Klassen à la "HashSetIterator" aber nicht gefunden.

Es wäre sehr nett, wenn jemand eine bessere Interpretation des Zitates schreiben könnte...

Dafür auf jeden Fall vielen Dank!

Gruß
Wang

 

[F.S.WhiTeY]

Jede Klasse implementiert ihren eigenen Itterator<ObjectType>

Itterator<ArrayList>
Itterator<PriorityQueue>
Itterator<HashSet>


Wie eine ArrayList<Integer> oder ArrayList<double>

Edit: Man nennt das auch TypeBinding

LG

 

[Wang]

Danke, aber irgendwie dämmert es mir noch nicht...

Bei keiner Collection-Klasse taucht unter "All Implemented Interfaces:" das Interface "Iterator<E>" auf.
Wie soll dann eine Collection-Klasse ihre eigene Iterator-Klasse haben, die das Interface "Iterator<E>" implementiert?!

Wahrscheinlich stehe ich nur total daneben, bin aber für jede Erklärung sehr dankbar. ;-)

Gruß
Wang

EDIT:
Anscheinend stehe ich heute total daneben... Iterator<E> ist ja eine Schnittstelle, sprich die Methoden darin sind nicht implementiert, also sind auch hasNext() und next() nicht implementiert. Wie kann das hier unten dennoch funktionieren?

import java.util.*;

public class IterationAlt
{
   public static void main (String[] args)
   {
      // Array definieren
      int[] arr = {1, 2, 3, 4, 5 };

      // Collection anlegen
      List<Integer> coll = new ArrayList<Integer>();

      // Schleife, um Arrayelemente in Collection zu kopieren
      for (int i = 0; i < arr.length; ++i)
      {
         coll.add (new Integer (arr[i])); // Auto-Boxing
      }

      // Iterator erzeugen
      Iterator<Integer> iter = coll.iterator();

      // Schleife, um Elemente der Collection auszugeben
      while (iter.hasNext())          // weitere Elemente?
      {
         Integer value = iter.next(); // Zugriff über Iterator
         System.out.println ("Inhalt: " + value);  // Auto-Unboxing
      }
   }
}

 

[mvitz]

Schaut man sich den Sourcecode mal genauer an, dann ist es so:

...
public class ArrayList<E> extends AbstractList<E>
...

Und in AbstractList<E>:

...
    public Iterator<E> iterator() {
	return new Itr();
    }
...

Und Itr sieht dann folgendermaßen aus:

private class Itr implements Iterator<E> {
	/**
	 * Index of element to be returned by subsequent call to next.
	 */
	int cursor = 0;

	/**
	 * Index of element returned by most recent call to next or
	 * previous.  Reset to -1 if this element is deleted by a call
	 * to remove.
	 */
	int lastRet = -1;

	/**
	 * The modCount value that the iterator believes that the backing
	 * List should have.  If this expectation is violated, the iterator
	 * has detected concurrent modification.
	 */
	int expectedModCount = modCount;

	public boolean hasNext() {
            return cursor != size();
	}

	public E next() {
            checkForComodification();
	    try {
		E next = get(cursor);
		lastRet = cursor++;
		return next;
	    } catch (IndexOutOfBoundsException e) {
		checkForComodification();
		throw new NoSuchElementException();
	    }
	}

	public void remove() {
	    if (lastRet == -1)
		throw new IllegalStateException();
            checkForComodification();

	    try {
		AbstractList.this.remove(lastRet);
		if (lastRet < cursor)
		    cursor--;
		lastRet = -1;
		expectedModCount = modCount;
	    } catch (IndexOutOfBoundsException e) {
		throw new ConcurrentModificationException();
	    }
	}

	final void checkForComodification() {
	    if (modCount != expectedModCount)
		throw new ConcurrentModificationException();
	}
    }

 

[Landei]

Jede Klasse implementiert ihren eigenen Itterator<ObjectType>

Itterator<ArrayList>
Itterator<PriorityQueue>
Itterator<HashSet>


Wie eine ArrayList<Integer> oder ArrayList<double>

Edit: Man nennt das auch TypeBinding

LG

An dem Beitrag ist so viel falsch, dass es schon wehtut:
- es heißt "Iterator", nicht "Itterator"
- man kann für jede Klasse K einen Iterator<K> implementieren, er ist aber nicht schon implementiert
- Man kann natürlich auch einen Iterator<ArrayList> schreiben, allerdings ist im Allgemeinen der Iterator über die Elemente einer ArrayList interessanter (und darauf wollte der TO auch hinaus)
- Die Collection-Klassen implementieren nicht direkt Iterator<E>, sonder Iterable<E>, dessen iterator-Klasse einen Iterator<E> zurückliefert
- Eine ArrayList<double> gibt es nicht, primitive Typen sind nicht als Generics erlaubt

 

[Wang]

mvitz hat den Nagel genau auf dem Kopf getroffen! :applaus:

Eine Sache noch:
Ich kann die "private class Itr" nirgends im src-Ordner finden, kann mir bitte jemand verraten, wo ich die entsprechende Quelldatei finden kann?

Thanks!

Gruß
Wang

 

[Marco13]

Diese Klasse liegt als innere Klasse AFAIR in der "AbstractList.java"

 

[Wang]

Danke, Marco!

Kleiner Off-Topic:
Mit dem "Spiel des Lebens" haben wir es dann doch noch hinbekommen, lag aber daran, dass einer in der Gruppe schon etwas mehr Ahnung von Java hatte... Auf jeden Fall nutze ich jetzt in den Ferien jeden einzelnen Tag, um das Buch "Java als erste Programmiersprache" durchzuarbeiten und meine Skills zu erweitern/verbessern.
Das Kapitel über RMI überspringe ich vorerst aber, denn wir können auch Sockets benutzen.

Gruß
Wang