Question

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

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

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

我要做的是给方法一个开始和结束，如（数组，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）设置为开始位置
每次拨打下一个电话时，请增加i2。
- 如果内部数组结束，请将i2重置为0（环绕）并增加i1。
- 如果外部数组结束，请将i1重置为0（环绕）。
如果i1 == s1 && i2 == s2您已到达终点，请停在那里。

由于i1 == s1 && i2 == s2在开头和结尾都为真，你需要一个布尔字段来跟踪差异。

因为＆＃34; istVorwaerts＆＃34;意味着＆＃34; isForward＆＃34;和＆＃34; istZeilenweise＆＃34;意味着＆＃34; isLinewise＆＃34;或类似的东西，您当然会调整上述逻辑来处理这4种情况，就像您现在一样，这样您就可以在所有4个方向上迭代2D数组。 / p>

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

我还建议使用静态工厂方法创建一个包装器Iterable类，这样你就可以做这样的事情来反向循环迭代：

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

通过2d数组重新启动迭代

1 个答案: