在Java for循环中保留集合的上一个元素，即使继续

我需要将下一个元素与上一个元素匹配。条件是我想继续迭代。但我不喜欢将分配复制/粘贴到上一个元素：

List<Type> all;
Type prev = null;
for (Type curr : all) {
    if (prev == null) {
        prev = curr;
        continue;
    }
    if (isBad(curr)) {
        prev = curr;
        continue;
    }
    if (! curr.match(prev)) {
        prev = curr;
        continue;
    }
    process(prev, curr);
    prev = curr;
}

---

因为processprev、curr而作弊；不应该有凹痕。错误检查逻辑不应该为强制缩进的主执行逻辑而烦恼。

据我所知，在所有的if-s中都是这样做的。因此，您可以在if中使用or | |：

---

通过组合3条if语句，可以消除continue语句，并使代码更清晰：

for (Type curr : all) {
    if (prev != null && !isBad(curr) && curr.match(prev)) {
        process(prev, curr);
    }
    prev = curr;
}

为什么不使用或| |

i、 e

---

从脚本中删除所有“继续”

通过使用else-if将if语句链接在一起并在末尾的else块中包含进程，或者通过组合条件并交换块来执行此操作：

for (Type curr : all) {
    if (prev != null &&
        !isBad(curr) &&
        curr.match(prev)) {
        process(prev, curr);
    }
    prev = curr;
}

或

---

只需使用或| |并将条件放入具有相关名称的方法中：

public void myMethod(){
    List<Type> all;
    Type prev = null;
    for (Type curr : all) {
            if (isContinue()) {
                prev = curr;
                continue;
            }
            process(prev, curr);
            prev = curr;
    }
}


private boolean isContinue(){
    return (prev == null || isBad(curr) || !curr.match(prev);
}

---

可以使用带有索引的for循环，这样就可以读取“ahead”，而不应该对前一个循环使用变量，在这种情况下，i的最后一个值必须是size-1

    List<Type> all;
    Type prev = null;
    for(int i=0; i<all.size()-1; i++) {
        if(isBad(all.get(i)) {
            continue;
        }
        if(all.get(i).match(all.get(i+1)) {
            continue;
        }

        ...
    }

我想到：

List<Type> all;
Type prev = null;
Type curr = null;
Iterator<Type> iter = all.iterator();
for (; iter.haSNext(); prev = curr) {
    curr = iter.next();
    if (prev == null)
        continue;
    if (isBad(curr))
        continue;
    if (! curr.match(prev))
        continue;

    process(prev, curr);
}

我写道

---

因此，我发现Java miss goto语句，使用该语句进行强制限制的实现将是微不足道的。

这三个独立的if条件是仅用于演示目的，还是它们之间真的没有说明？在正确编辑问题之前，我收到了答案。请把它删掉。缩进是怎么回事？这看起来像学术风格的代码清理。无论如何，问题是您是否要处理坏的prev项？如果是，那么你的作弊代码就可以了。错误检查和前置条件不应该影响主执行流。由于检查而缩进主代码，可以混合检查和操作流。您是否因断言而缩进代码？我认为不…错误检查和前置条件是主要执行流程的一部分。断言。断言。。。这是测试的一部分。断言将终止无效数据，即！那是另一回事。在您的情况下，您愿意处理坏值，只要它们在prev引用中。我建议在这个方法的背景下工作。对不起，我更新了答案。它有一点是您的解决方案不合适的。java迭代器不支持这种“预读”方式。你可以用你所拥有的。

for (Type curr : all) {
    if (prev != null) {
    }
    else if (isBad(curr)) {
    }
    else if (! curr.match(prev)) {
    }
    else {
        process(prev, curr);
    }
    prev = curr;
}

public void myMethod(){
    List<Type> all;
    Type prev = null;
    for (Type curr : all) {
            if (isContinue()) {
                prev = curr;
                continue;
            }
            process(prev, curr);
            prev = curr;
    }
}


private boolean isContinue(){
    return (prev == null || isBad(curr) || !curr.match(prev);
}

    List<Type> all;
    Type prev = null;
    for(int i=0; i<all.size()-1; i++) {
        if(isBad(all.get(i)) {
            continue;
        }
        if(all.get(i).match(all.get(i+1)) {
            continue;
        }

        ...
    }

List<Type> all;
Type prev = null;
Type curr = null;
Iterator<Type> iter = all.iterator();
for (; iter.haSNext(); prev = curr) {
    curr = iter.next();
    if (prev == null)
        continue;
    if (isBad(curr))
        continue;
    if (! curr.match(prev))
        continue;

    process(prev, curr);
}