Next()-Aufruf zweimal innerhalb einer While-Schleife bei ListIterator

[LILA]

Hallo Forum,

ich habe generelle Verständnisfragen:

Ist es erlaubt die next-Methode zweimal innerhalb einer While-Schleife aufzurufen?
Und wenn nein, wieso nicht?

Desweiteren würde mich interessieren, ob es möglich ist, einen Iterator wie ich es gemacht habe in der Methode 'checkNumberOfFollowingLayers(iterator)' zu übergeben? Um später wieder auf das selbe Element zuzugreifen, gehe ich mit dem Iterator anschließend mit previous wieder zurück...

Bei mir macht der Iterator nicht das was ich erwarte. D.h. er gibt teilweise Elemente zweimal zurück etc. Kann das sein, dass es daran liegt, dass man mit einem Iterator nicht wie folgt umgehen darf?

Beispiel:

ListIterator<Tree> iterator = treeArray.listIterator();
while (iterator.hasNext()) {
    //*****Erster Aufruf next()
    Tree tree = iterator.next();
    level = tree.getLevel();
    isLayer = tree.getLayerId();
    //Some code here
    if (level == 3 && isLayer != 0){
        //*****Methodenaufruf und Übergabe des Iterators
        int number = checkNumberOfFollowingLayers(iterator);
        for (int i = 0; i <= number; i++) {
            //Some code here
            //*****Zweiter Aufruf next()
            tree = iterator.next();
        }
//Some code here
private int checkNumberOfFollowingLayers(ListIterator<Tree> iterator) {
    int number = 0;
    int isLayer;
    //*****Innerhalb der Methode wird sowohl iterator.next().........
    while (iterator.hasNext()) {
        Tree tree = iterator.next();
        isLayer = tree.getLayerId();
	if (isLayer != 0) {
	    number = number + 1;
	} else {
	    break;
	}
    }
    //*****.......... als auch iterator.previous() genutzt
    for (int i = 0; i <= number; i++) {
        iterator.previous();
    }
    return number;
}

Vielen Dank für eure Antworten.
Schöne sonnige Grüße

 

[ssoul26]

*empty*

 

[SlaterB]

eine while-Schleife ist kein feste Code-Erlaubnis-Struktur sondern nur eine Anordnung von Befehlen,

wenn du dir im wahren Leben die 'Verhaltens-Schleife' 'eine Steckdose mit dem Spannungsprüfer testen, dann jeweils zwei sorglos aufschrauben' zurechtlegst, verbietet dir das niemand, aber du solltest dich nicht wundern wenn du einen Schlag bekommst

hier wohl genauso, hasNext() prüft nur für den ersten next()-Aufruf, die weiteren machst du ohne Netz und doppelten Boden

 

[LILA]

Aber später Zeile 14 rufe ich iterator.next() erneut auf...
Ist das ein Problem?

 

[ssoul26]

Aber später Zeile 14 rufe ich iterator.next() erneut auf...
Ist das ein Problem?

Der Aufruf an sich wäre kein Problem. Würde vorher noch mal abfragen auf hasNext.

 

[ssoul26]

Was gibt er denn aus?

 

[hüteüberhüte]

Also eigentlich prüfst du ja vorher mit .hasNext, ob .next noch etwas zurück gibt oder nicht. Wenn du sicherstellen kannst, dass so und so viele Elemente vorhanden sind, brauchst du natürlich nicht prüfen, aber ansonsten ist das eher unsicher

 

[Plopo]

Aber später Zeile 14 rufe ich iterator.next() erneut auf...
Ist das ein Problem?

Ja, solltest du vorher nicht auf ".hasNext()" prüfen und beim letzen Element bereits angelagt sein,
wirft dir der Compiler ne Exception um die Ohren.

Throws:
NoSuchElementException - iteration has no more elements.

Quelle

 

[LILA]

Erstmal vielen Dank euch, für eure ganzen Antworten!
Nun ist mir klar, dass ich einfach immer abfragen muss, ob noch wirklich weitere Elemente in dem Iterator vorhanden sind.

Bei folgendem Code gibt es allerdings noch ein Problem:

Ich habe folgende Inhalte in meiner Array-List:
- Name - Level
- UmweltA - 1
- UmweltB - 2
- UmweltC - 3

Code:

		ListIterator<Tree> iterator = treeArray.listIterator();
		while (iterator.hasNext()) {

			tree = iterator.next();
			level = tree.getLevel();
			isLayer = tree.getLayerId();

			if (level == 1) {
                              //do Something
			}
			
			if (level == 2 && isLayer == 0) {
                              //do Something
			}
			
			if (level == 3 && isLayer == 0){
                              //do Something
			      Tree topLevelFolder = findTopLevelFolder(2, iterator);
			}

private Tree findTopLevelFolder(int level, ListIterator<Tree> iterator) {


		int number = 0;

		while (iterator.hasPrevious()) {
			tree = iterator.previous();
			treeLevel = tree.getLevel();

			number = number + 1;
			if (treeLevel == level) {

		}
		for (int i = 0; i < number; i++) {
			iterator.next();
		}

Ich durchlaufe meine Liste und springe in für das erste Element in die erste If-Schleife, bei dem zweiten Element springe ich in die zweite If-Schleife. Bei dem dritten Element springe ich in die dritte If-Schleife und dort rufe ich meine private Methode findTopLevelFolder auf...

Dieser Methode übergebe ich meinen Iterator. Und in Zeile 27 bei tree = iterator.previous wird laut Debugger nur der cusor des Iterators eins nach unten gezählt. Der zugewiesene Tree bleibt derselbe. Erst wenn ich ein zweites Mal iterator.previous aufrufe, wird das niedrigere Element in den Tree geschrieben...
Hat hier jemand eine Idee, warum das so ist und ob das normal ist?

 

[SlaterB]

if-schleife.de ist nicht normal,

das Iterator-Verhalten allerdings schon, also so implementiert, stören würde mich das wohl auch, bin da noch nie vorbeitgekommen

E previous()

Returns the previous element in the list. This method may be called repeatedly to iterate through the list backwards, or intermixed with calls to next to go back and forth. (Note that alternating calls to next and previous will return the same element repeatedly.)

ListIterator (Java Platform SE 6)

 

[LILA]

Hallo SlaterB,

dann ist das also tatsächlich normal so, danke!

Ok, dann in Zunkft if-Abfrage 🙂

Dann werde ich mal weiter wurschtln...