java - 通过二维数组重新开始迭代

Question

我正在尝试通过二维数组重新启动迭代。我使用以下数组进行测试:

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

我的 toString 方法的结果是 1, 2, 3, 4, 5, 6, 7, 8, 9。(带有 next-method 的迭代器来获取每个值)

我想做的是给该方法一个像 (array, 1, 2) 这样的开始和结束来获得这个结果:

6、7、8、9、1、2、3、4、5。

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

当前代码:

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;
}

}

感谢您的建议!

Answer 1

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

• 保存起始位置(s1,s2)
• 将索引字段(i1、i2)设置为起始位置
• 每次调用 next 时，递增 i2。
  • 如果到达内部数组末尾，则将 i2 重置为 0(环绕)并递增 i1。
  • 如果是外部数组的末尾，则将 i1 重置为 0(环绕)。
• 如果i1 == s1 && i2 == s2您已到达末尾，并在那里停止。

由于 i1 == s1 && i2 == s2 在开始和结束时都为 true，因此您需要一个 boolean 字段来跟踪差异。

<小时/>

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

鉴于这 4 种情况之间的共享代码非常少，我建议改为创建 4 个迭代器类。

我还建议使用静态工厂方法创建一个包装器Iterable类，这样您就可以执行类似的操作以相反方向按行迭代:

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