Interface Iterator

H

hesat

Neues Mitglied
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
IntegerArrayIterator(int[] array) erzeugt werden konnen. Um das Interface
Iterator<Integer> zu realisieren, muss die Klasse folgende Methoden aufweisen:
 public boolean hasNext(): Diese Methode soll anhand des Attributs index
uberprufen, ob der nachste Index noch im Array liegt. Ist dies der Fall, so soll
"true\ zuruckgegeben werden. Sonst soll "false\ zuruckgegeben werden.
 public Integer next(): Diese Methode soll den internen index um eins erhohen
und den nachsten Wert zuruckgeben.
 public void remove(): Diese Methode soll den aktuellen Wert aus dem Array
entfernen. Dazu muss ein neues Array angelegt werden, das um ein Element kurzer
ist. Dann mussen alle Elemente des alten Arrays bis auf das aktuelle, das von der
Variable index angezeigt wird, in das neue Array umgezogen werden.
Implementieren Sie zum Testen ihrer Klasse eine Methode public static void
main(String[] args), die eine neue Instanz des IntegerArrayIterator mit denWerten
f1, 3, 3, 7g erzeugt. Danach soll mittels einer while-Schleife uber das Objekt
iteriert werden und jedes Element mittels System.out.println() ausgegeben werden.
Zum Vergrößern anklicken....
Java: 
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

Rudolf

Bekanntes Mitglied
Hab hier mal was hingeklatscht:

Java: 
@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();
    
}

Java: 
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
Java: 
public static void main(String[] args) {
und nicht
Java: 
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.
 
Zuletzt bearbeitet:
B

Beni

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

Landei

Top Contributor
Von hinten durch die Brust ins Auge:
Java: 
    @Override
    public Integer next() {
        return Array.getInt(this.array, this.index++);
    }

Spricht irgend etwas gegen das prosaische
Java: 
    @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.
 
A

Andi_CH

Top Contributor
Ist das so tragisch?

Java: 
	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 :) )
 
M

maki

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

Andi_CH

Top Contributor
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.
 
M

maki

Gast
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.
 
A

Andi_CH

Top Contributor
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.

Java: 
    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);
    }
 
Zuletzt bearbeitet:
M

Marco13

Top Contributor
remove war explizit gefordert

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

Mc Noise

Gast
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

Rudolf

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

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

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

Andi_CH

Top Contributor
Vorgabe:
Code: 
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.
 
B

Beni

Gast
Rudolf hat gesagt.:
Beni, was soll das Smily bedeuten. Checkst du das nicht?
Zum Vergrößern anklicken....
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.
 
A

Andi_CH

Top Contributor
Landei hat gesagt.:
Okay, okay...

Zum Kopieren aber keine Schleife, sondern [c]System.arrayCopy()[/c] nehmen.
Zum Vergrößern anklicken....

zu Befehl Sir.

Java: 
	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

Landei

Top Contributor
Sehr vorbildlich!

bundesverdienstkreuz-am-ban.jpg
 

Aktuelle Jobs

Neue Themen


Oben