Question

我需要将下一个元素与之前的元素相匹配。在条件我想continue迭代。但我不喜欢将作业复制/粘贴到上一个元素：

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

如何避免prev = curr重复？

我认为这个解决方案：

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

是作弊，因为process(prev, curr);不应该缩进。错误检查逻辑不应该打扰主执行逻辑（强制缩进）。

Answer 1

你可以使用索引的for循环，这样你就可以阅读＆＃39;提前＆＃39;并且你不应该使用前一个变量，在这种情况下，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;
        }

        ...
    }

Answer 2

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

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

Answer 3

为什么不使用OR（||）。

即

if (prev == null || isBad(curr) || ! curr.match(prev) ) {
    prev = curr;
    continue;
}

Answer 4

全部删除＆＃34;继续＆＃34;来自你的剧本。

通过使用＆＃34;将if语句链接在一起来执行此操作;否则，如果＆＃34;并在最后的else块中使用process（），或者通过组合条件并交换块来实现：

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

或

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

Answer 5

只需使用OR（||）并将条件放在具有相关名称的方法中：

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

Answer 6

我想：

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

我写了blog post about this topic with more detailed examples。

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

Answer 7

据我所知，你在所有的if-s中做同样的事情。因此，您可以使用||中的if：

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

将以前的集合元素保存在Java中，即使在继续时也是如此

7 个答案: