Java 通过二维数组重新启动迭代

我正在尝试通过2d数组重新启动迭代。我正在使用以下阵列进行测试：

{{1,2,3}，{4,5,6}，{7,8,9}

我的toString方法的结果是1,2,3,4,5,6,7,8,9。 （使用下一个方法获取每个值的迭代器）

我要做的是给这个方法一个类似（array，1，2）的起点和终点，以得到这个结果：

6，7，8，9，1，2，3，4，5

我的gues是使用一个变量来检查位置。但在达到这个位置之前，我不知道如何重新开始迭代

当前代码：

import java.util.Iterator;

public class IteratorForArray<T> implements Iterator<T> {
private T[][] array;
private boolean istZeilenweise, istVorwaerts, next;
private int zeile, zStart;
private int spalte, sStart, index;
private T wert;

public IteratorFuerArray2(T[][] array, boolean istZeilenweise, boolean istVorwaerts, int zStart, int sStart) {
    this.array = array;
    this.istZeilenweise = istZeilenweise;
    this.istVorwaerts = istVorwaerts;
    this.zStart = zStart;
    this.sStart = sStart;

    if (istVorwaerts) {
        zeile = this.zStart;
        spalte = this.sStart;
    } else {
        zeile = zStart;
        spalte = sStart;
    }
}

@Override
public boolean hasNext() {
    if (istZeilenweise) {
        if (this.istVorwaerts) {
            next = (zeile < this.array.length && spalte < this.array.length);
        } else {
            next = (zeile >= 0) && spalte >= 0;
        }
    } else {
        if (this.istVorwaerts) {
            next = zeile < this.array.length && spalte < this.array.length;
        } else {
            next = zeile >= 0 && spalte >= 0;
        }
    }
    return next;
}

@Override
public T next() {
    if (!hasNext()) {
        return null;
    }
    if (this.istZeilenweise == true) { // zeilenweise
        if (this.istVorwaerts) { // vorwärts
            wert = zeilenweiseVor();
        } else { // rückwärts
            wert = zeilenweiseRueck();
        }
    } else { // spaltenweise
        if (this.istVorwaerts) { // vorwärts
            wert = spaltenweiseVor();
        } else { // rückwärts
            wert = spaltenweiseRueck();
        }
    }
    return wert;
}

private void resetVor() {
    if (this.istZeilenweise) { // zeilenweise
        if (spalte == this.array[zeile].length) {
            spalte = 0;
            zeile++;
        }
    } else { // spaltenweise
        if (zeile == this.array[spalte].length) {
            zeile = 0;
            spalte++;
        }
    }
}

private void resetRueck() {
    if (istZeilenweise) { // zeilenweise
        if (spalte < 0) {
            spalte = this.array[zeile].length - 1;
            zeile--;
        }
    } else { // spaltenweise
        if (zeile < 0) {
            zeile = this.array[spalte].length - 1;
            spalte--;
        }
    }
}

public T zeilenweiseVor() {
        while (zeile < this.array.length) {
            while (spalte < this.array[zeile].length) {
                if (this.array[zeile][spalte] != null) {
                    wert = this.array[zeile][spalte];
                    spalte++;
                    resetVor();
                    return wert;
                } else {
                    spalte++;
                    resetVor();
                }
            }
            zeile++;
        }
    return wert;
}

public T zeilenweiseRueck() {
    while (zeile >= 0) {
        while (spalte >= 0) {
            if (this.array[zeile][spalte] != null) {
                wert = this.array[zeile][spalte];
                spalte--;
                resetRueck();
                return wert;
            } else {
                spalte--;
                resetRueck();
            }
        }
        zeile--;
    }
    return wert;
}

public T spaltenweiseVor() {
    while (zeile < this.array.length) {
        while (spalte < this.array[zeile].length) {
            if (this.array[zeile][spalte] != null) {
                wert = this.array[zeile][spalte];
                zeile++;
                resetVor();
                return wert;
            } else {
                zeile++;
                resetVor();
            }
        }
        spalte++;
    }
    return wert;
}

public T spaltenweiseRueck() {
    while (zeile >= 0) {
        while (spalte >= 0) {
            if (this.array[zeile][spalte] != null) {
                wert = this.array[zeile][spalte];
                zeile--;
                resetRueck();
                return wert;
            } else {
                zeile--;
                resetRueck();
            }
        }
        spalte--;
    }
    return wert;
}

public String toString() {
    String ausgabe = "";
    while (hasNext()) {
        ausgabe += next();
        if (hasNext()) {
            ausgabe += ", ";
        } else {
            ausgabe += ".";
        }
    }
    return ausgabe;
}

import java.util.Iterator；
公共类迭代器ForArray实现迭代器{
专用T[][]阵列；
私有布尔值istZeilenweise，istVorwaerts，next；
私人国际酒店，zStart；
私有int-spalte、sStart、index；
私人T-wert；
公共迭代器fuerarray2（T[][]数组，布尔istZeilenweise，布尔istVorwaerts，int-zStart，int-ssStart）{
this.array=数组；
this.istZeilenweise=istZeilenweise；
this.istVorwaerts=istVorwaerts；
this.zStart=zStart；
this.sStart=sStart；
if（istVorwaerts）{
zeile=this.zStart；
spalte=this.sStart；
}否则{
zeile=zStart；
spalte=sStart；
}
}
@凌驾
公共布尔hasNext（）{
如果（istZeilenweise）{
如果（此为istVorwaerts）{
next=（zeile=0）和&spalte>=0；
}
}否则{
如果（此为istVorwaerts）{
next=zeile=0&&spalte>=0；
}
}
下一步返回；
}
@凌驾
公共交通工具{
如果（！hasNext（））{
返回null；
}
如果（this.istZeilenweise==true）{//zeilenweise
如果（this.istVorwaerts）{//vorwärts
wert=zeilenweiseVor（）；
}否则{//rückwärts
wert=ZeilenWeserueck（）；
}
}else{//spaltenweise
如果（this.istVorwaerts）{//vorwärts
wert=spaltenweiseVor（）；
}否则{//rückwärts
wert=SPALTENWESERUECK（）；
}
}
返回wert；
}
私人无效重置VOR（）{
如果（this.istZeilenweise）{//zeilenweise
if（spalte==this.array[zeile].length）{
spalte=0；
zeile++；
}
}else{//spaltenweise
if（zeile==this.array[spalte].length）{
zeile=0；
spalte++；
}
}
}
私有无效重置{
如果（istZeilenweise）{//zeilenweise
如果（spalte<0）{
spalte=this.array[zeile].length-1；
泽尔--；
}
}else{//spaltenweise
if（zeile<0）{
zeile=this.array[spalte].length-1；
垃圾--；
}
}
}
公共T zeilenweiseVor（）{
while（zeile=0）{
而（spalte>=0）{
if（this.array[zeile][spalte]！=null）{
wert=this.array[zeile][spalte]；
垃圾--；
resetRueck（）；
返回wert；
}否则{
垃圾--；
resetRueck（）；
}
}
泽尔--；
}
返回wert；
}
公共T spaltenweiseVor（）{
while（zeile=0）{
而（spalte>=0）{
if（this.array[zeile][spalte]！=null）{
wert=this.array[zeile][spalte]；
泽尔--；
resetRueck（）；
返回wert；
}否则{
泽尔--；
resetRueck（）；
}
}
垃圾--；
}
返回wert；
}
公共字符串toString（）{
字符串ausgabe=“”；
while（hasNext（））{
ausgabe+=next（）；
if（hasNext（））{
ausgabe+=“，”；
}否则{
ausgabe+=”；
}
}
返回ausgabe；
}

}

---

谢谢你的建议

所有字段和变量名都是德语，这有点难理解，但逻辑如下：

• 保存起始位置（

  s1

  ，

  s2

  ）
• 将索引字段（

  i1

  ，

  i2

  ）设置为起始位置
• 每次调用next时，递增

  i2

  。
  • 如果内部数组结束，则将

    i2

    重置为0（环绕），并递增

    i1

  • 如果外部阵列结束，则将

    i1

    重置为0（环绕）
• 如果

  i1==s1&&i2==s2

  您已经到达终点，并停在那里

由于

i1==s1&&i2==s2

在开头和结尾都是真的，所以需要一个布尔字段来跟踪差异

---

由于“istVorwaerts”表示“isForward”，而“istZeilenweise”表示“isLinewise”，或者类似的，您当然会调整上面描述的逻辑以处理这4种情况，就像您已经在做的一样，这样您就可以在所有4个方向上迭代2D数组

考虑到有非常多的

for (MyClass obj : IterableArray2.up(myarray, 1, 2)) {
    // code here
}