Eigener Iterator soll mehrdimensionales Array durchlaufen

[werdas34]

Hallo,

ich habe eine Aufgabe (siehe Bild).
Im grunde gehts darum einen Iterator zu schreiben der die Zahlen einen mehrdimensionalen Arrays ausgibt und selbständig erkennt wann ein Array endet. Dann muss er gegebenfalls in den nächsten springen.
Mein Code:

import java.util.Iterator;

public class IterableArrays implements Iterable<Integer> {
    private final int[][] arrays;

    public IterableArrays(int[]... arrays) {
        this.arrays = arrays;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new IntIterator();
    }

    private class IntIterator implements Iterator<Integer> {
        private int indexArr = 0;
        private int indexCurrentElement = 0;

        private void findNext() {
            if (this.hasNext()) {
                if (arrays[indexArr].length < arrays.length) {
                    indexArr++;
                    indexCurrentElement = 0;
                }
            }
        }

        @Override
        public boolean hasNext() {
            return indexCurrentElement < arrays[indexArr].length;
        }

        @Override
        public Integer next() {
            findNext();
            return arrays[indexArr][indexCurrentElement++];
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

    }
}

Main:

import java.util.Iterator;

public class Main {

    public static void main(String[] args) {
        int[][] arr =
            { { 1, 9, 4 },
              { 0, 2},
              { 0, 1, 2, 3, 4 } };
       
        IterableArrays it = new IterableArrays(arr);
        Iterator<Integer> iter = it.iterator();
       
        while(iter.hasNext()) {
            System.out.println(iter.next());
        }
    }

}

Momentan wird nur die erste Zeile ausgeben also:
1
9
4

Nur ich finde irgendwie meinen Fehler grad nicht.
Wäre super wenn mir jemand hilft.

Danke
mfg werdas34

 

[httpdigest]

Folgt zwar nicht exakt der Aufgabe, aber...

import java.util.*;
public class IterableArrays implements Iterable<Integer> {
  private final int[][] arrays;
  public IterableArrays(int[]... arrays) {
    this.arrays = arrays;
  }
  @Override
  public Iterator<Integer> iterator() {
    return Arrays.stream(arrays).flatMapToInt(Arrays::stream).iterator();
  }
}

Ansonsten ist bei dir der Fehler, dass du in hasNext() nur auf das aktuelle Array und dessen Länge guckst und nicht prüfst, ob (wenn das Array erschöpft ist), du vielleicht noch mehr arrays hast.

 

[werdas34]

Danke für deine Antwort.
Ich würde dennoch gerne die Aufgabe aufgabengerecht lösen - Prüfung...

Habe jetzt bisschen rumprobiert. Also momentan siehts so aus:

        @Override
        public boolean hasNext() {
            if(indexCurrentElement < arrays[indexArr].length) {
                return true;
            }
            if(arrays[indexArr].length < arrays.length) {
                return true;
            }
            return false;
        }

Ausgabe ist das selbe wie oben.

Also entweder bin ich grad zu dumm dafür oder mein Gehirn hat mittlerweile keine Lust mehr. Ich schaue morgen nochmal drüber schauen.
Würde mich dennoch über Tipps freuen.

mfg werdas34

 

[httpdigest]

Effektiv brauchst du eigentlich eine while/for Schleife, um das nächste wirkliche Array-Element zu finden. Bedenke, dass Arrays auch leer sein können und du somit solange Arrays prüfen musst, bis du ein wirkliches Element gefunden hast, das der Iterator als nächstes zurückliefern kann.

Hier ist eine mögliche funktionierende Lösung (bitte erst vorher selber probieren!):

Spoiler

private class IntIterator implements Iterator<Integer> {
  private int indexArr;
  private int indexCurrentElement = -1;
  private boolean hasNext = proceed();
  private boolean proceed() {
    // Gehe im aktuellen Array eine Position weiter
    indexCurrentElement++;
    // Solange wie noch Arrays übrig sind...
    while (indexArr < arrays.length) {
      // Prüfe, ob das aktuelle Array noch Element hat
      if (indexCurrentElement >= arrays[indexArr].length) {
        // Nein, es ist erschöpft. Gehe zum nächsten Array.
        indexArr++;
        indexCurrentElement = 0;
      } else {
        // Ein nächstes Element wurde gefunden
        return true;
      }
    }
    // Alle Arrays wurden iteriert
    return false;
  }
  @Override
  public boolean hasNext() {
    return hasNext;
  }
  @Override
  public Integer next() {
    if (!hasNext)
      throw new NoSuchElementException();
    try {
      return arrays[indexArr][indexCurrentElement];
    } finally {
      hasNext = proceed();
    }
  }
}

 

[Xyz1]

Tipp: Zweiter Iterator/iterable.