# Interface Iterator



## hesat (18. Jan 2011)

Hallo, 
bin bei einer Aufgabe und krieg den Rückgabewert nicht raus.
Hat einer vlt ne Ahnung wie?
Hier die Aufgabe


> Erstellen Sie eine neue Klasse IntegerArrayIterator.java, die das Interface
> Iterator<Integer> implementiert. Die Klasse soll die Möglichkeit bieten, über
> ein Array von Integer-Werten zu iterieren, um auf alle Elemente des Arrays nach
> und nach zugreifen zu können. Objekte der Klasse sollen mit einem Konstruktor
> ...




```
public class IntegerArrayIterator {

	public int[] kontrolle = new int[] {};

	public int index = -1;

	public boolean hasNext(int test) {
		int len = this.kontrolle.length;
		if (len > test)
			return true;

		else
			return false;

	}

	public int next() {
		index++;
		return index;

	}

	public void remove() {

		int a = 0;

		while (a < kontrolle.length) {
			if (a != index) {
				kontrolle[a] = kontrolle[a];

			}
			a++;
		}
	}

	public static int main(String[] args) {

		int Wert = 0;
		int[] felder = new int[] { 1, 3, 3, 7 };
		IntegerArrayIterator a = new IntegerArrayIterator();

		a.kontrolle = felder;
		while (a.hasNext(Wert) == true) {
			try {
				Wert = a.next();
				System.out.println(a.kontrolle[Wert]);
				a.remove();
			} catch (Exception sle) {
				return 0;
			}
		}

	}

}
```


----------



## Rudolf (18. Jan 2011)

Hab hier mal was hingeklatscht:


```
@SuppressWarnings("hiding")
public interface Iterator<Integer> {

	 /**
     * Returns {@code true} if the iteration has more elements.
     * @return {@code true} if the iteration has more elements
     */
    boolean hasNext();

    /**
     * Returns the next integer element in the iteration.
     * @return the next integer element in the iteration
     */
    Integer next();

    /**
     * Removes the last element returned by this iterator (optional operation). 
     */
    void remove();
    
}
```


```
import java.lang.reflect.Array;
public class IntegerArrayIterator implements Iterator<Integer> {

	private int[] array;
	private int index;
	
	/**
	 * Constructor for {@link IntegerArrayIterator}
	 * @param array
	 */
	public IntegerArrayIterator(int[] array) {
		if (!array.getClass().isArray()) {
			throw new IllegalArgumentException("not an array");
		}
		this.array = array;
		this.index = 0;
	}


	/** {@inheritDoc} */
	@Override
	public boolean hasNext() {
		return this.index < this.array.length;  
	}

	/** {@inheritDoc} */
	@Override
	public Integer next() {
		return Array.getInt(this.array, this.index++);
	}

	/** {@inheritDoc} */
	@Override
	public void remove() {
		int[] newArray = new int[this.array.length-1];
		for (int i = 0; i < newArray.length; i++) {
			newArray[i] = this.array[i];
		}
		this.array = newArray;
	}
	
	/**
	 * testing
	 * @param args
	 */
	public static void main(String[] args) {
		int[] array = { 1, 3, 3, 7 };
		Iterator<Integer> arrayIterator = new IntegerArrayIterator(array);
		while (arrayIterator.hasNext()) {
			int i = arrayIterator.next();
			System.out.println(i);
		}
		//TODO remove() testing implementation
	}
	
}
```

Und zu deinem Code:

1. schreibt man Membervariablen niemals in public. Das ist schlechter Programmierstil. Regel: So lokal wie möglich, so public wie nötig. Wenn dann möglichst private final.
2. meinst du 
	
	
	
	





```
public static void main(String[] args) {
```
 und nicht 
	
	
	
	





```
public static int  main(String[] args) {
```
3. joa ansonsten ist mir nicht klar, was du da machen möchtest. Schreibe mal ein paar Testfälle, damit klar wird bei welchem Input du welchen Output erwartest.


----------



## Marco13 (18. Jan 2011)

Vielleicht sollte man erwähnen, dass java.util.Iterator verwendet werden könnte (und wohl auch sollte...)


----------



## Rudolf (19. Jan 2011)

Marco13 hat gesagt.:


> Vielleicht sollte man erwähnen, dass java.util.Iterator verwendet werden könnte (und wohl auch sollte...)



joa habe ich auch nachher gecheckt^^


----------



## Beni (19. Jan 2011)

```
if (!array.getClass().isArray()) {
            throw new IllegalArgumentException("not an array");
        }
```
:bahnhof:


----------



## Landei (19. Jan 2011)

Von hinten durch die Brust ins Auge:

```
@Override
    public Integer next() {
        return Array.getInt(this.array, this.index++);
    }
```

Spricht irgend etwas gegen das prosaische

```
@Override
    public Integer next() {
        return array[index++];
    }
```

Ich würde übrigens bei [c]remove[/c] einfach eine UnsupportedOperationException werfen, die Methode ist laut JavaDoc optional und für Arrays nur umständlich zu implementieren.


----------



## Andi_CH (19. Jan 2011)

Ist das so tragisch?


```
public static int[] remove(int[] pArr, int pIndex) {
		int[] retVal = new int[pArr.length-1];
		int index = 0;
		while(index<pIndex){
			retVal[index] = pArr[index];
			index++;
		}
		while(index<retVal.length) {
			retVal[index]=pArr[index+1];
			index++;
		}
		return retVal;
	}
```

(Ja, lässt sich noch kompakter schreiben und Fehlerbehandlung gehört auch noch rein  )


----------



## maki (19. Jan 2011)

Andi_CH, das ist nicht die gesuchte remove Methode, diese hat nämlich diese Signatur:
[c]public void remove()[/c]


----------



## Andi_CH (19. Jan 2011)

Und ich denke immer ich sei Anfänger ???:L :noe:

Dann packt meine Methode doch einfach in deine Klasse rein und ruft sie aus der heraus mit den richigen Parametern (this.array - this.index oder wie auch immer die bei dir heissen) auf und weise das Resultat an this.array zu ......

Egal wem ich jetzt auf die Füsse trete: Mitdenken ist nicht nur erwünscht sondern Pflicht.


----------



## maki (19. Jan 2011)

Mitdenken darfst du gerne selber, die Frage war nach dem java.util.Iterator Interface, nicht nach andys.welt.IteratorUtils 

Irgendwie sollten deine Antworten auch zur Frage passen.


----------



## Andi_CH (19. Jan 2011)

Wie gesagt - mein Code lässt sich sicher in die gewünschte Implemetation umsetzen.

Sobald hier nicht nur Codeschnipsel sind, implementiere ich die - aber wenn ich jetzt wieder was mache passt es zu irgend etwas anderem nicht--- vielleich weil ich mIndex verwende und der TO index oder so ähnlich.

Vermutlich ist aber genau das gemeint.


```
private int[] remove(int[] pArr, int pIndex) {
        int[] retVal = new int[pArr.length-1];
        int index = 0;
        while(index<pIndex){
            retVal[index] = pArr[index];
            index++;
        }
        while(index<retVal.length) {
            retVal[index]=pArr[index+1];
            index++;
        }
        return retVal;
    }
    /** {@inheritDoc} */
    @Override
    public void remove() {
        this.array = remove(this.array, index);
    }
```


----------



## Marco13 (19. Jan 2011)

remove war explizit gefordert

EDIT: Notiz an mich: Nicht "antworten" klicken, 30 Minuten später schreiben, und NICHT vorher nochmal nach neuen Posts sehen


----------



## Bastie (19. Jan 2011)

Mensch Junge, das ist doch garnicht so schwer!  Schau dir deinen Konstruktor und den Compiler nochmal an!  Schnackelts?


----------



## Mc Noise (19. Jan 2011)

Ja schon eigentlich alles total easy. Bischen int, bischen array und paar sachen kuerzen, alles viel zu schwer. Eigentlich ist es in 20 zeilen machbar. alles total leger. 1337.


----------



## Rudolf (19. Jan 2011)

Landei, lese die Vorgaben für remove();

Beni, was soll das Smily bedeuten. Checkst du das nicht?

Landei, next() ist auch nett gelöst.


----------



## Andi_CH (19. Jan 2011)

Vorgabe:

```
public void remove(): Diese Methode soll den aktuellen Wert aus dem Array
entfernen. Dazu muss ein neues Array angelegt werden, das um ein Element kürzer
ist. Dann müssen alle Elemente des alten Arrays bis auf das aktuelle, das von der
Variable index angezeigt wird, in das neue Array umgezogen werden.
```

remove ist hier gelöst.


----------



## Landei (19. Jan 2011)

Okay, okay...

Zum Kopieren aber keine Schleife, sondern [c]System.arrayCopy()[/c] nehmen.


----------



## Beni (19. Jan 2011)

Rudolf hat gesagt.:


> Beni, was soll das Smily bedeuten. Checkst du das nicht?


Oh, was der Code macht ist mir schon klar. Nur wieso er dort steht nicht - die Bedingung wird niemals eintreten. Eine Variable die mit "int[]" angeschrieben ist, zeigt auch auf einen "int[]". Wenn schon, würde an der Stelle ein check auf "null" Sinn machen.


----------



## Andi_CH (19. Jan 2011)

Landei hat gesagt.:


> Okay, okay...
> 
> Zum Kopieren aber keine Schleife, sondern [c]System.arrayCopy()[/c] nehmen.



zu Befehl Sir.


```
public void remove() {
		int[] tmpArr = new int[this.array.length-1];
		System.arraycopy(this.array, 0, tmpArr, 0, index);
		System.arraycopy(this.array, index+1, tmpArr, index, this.array.length-index-1);
		this.array = tmpArr;
	}
```


----------



## Landei (19. Jan 2011)

Sehr vorbildlich!


----------

