Java 多重捕捉块和继续运算符

我遇到了一个使用多捕获块的问题，其中有一个异常可以应用于同一事件。请看下面的代码：

for (String currentString : stringsList) {
    try {
        Long.valueOf(currentString);
    } catch (NullPointerException e) {
        //do smth;
        continue; 
    } catch (NumberFormatException e) {
        //do smth;
        continue;
    }
    //do smth; 
} 

其思想如下：如果当前字符串变量为

null

，则执行特定操作，当前迭代完成，而无需检查

NumberFormatException

。但是当

currentString==null

下一个catch块无论如何都完成时，就会出现这种情况。我不明白为什么

continue

在这种情况下不起作用，并且第一个catch块没有留下。下一个解决方案是不可接受的，因为它不允许代码保留在循环中：

for (String currentString : stringsList) {
    try {
        Long.valueOf(currentString);
    } catch (NullPointerException e) {
        //do smth;
        break; 
    } catch (NumberFormatException e) {
        //do smth;
    } finally {
        continue;
    }
    //do smth; 
} 

我找到了解决方案，但它并不优雅：

for (String currentString : stringsList) {
    if (currentString == null) {
        //do smth;
        continue;
    }

    try {
        Long.valueOf(currentString);
    } catch (NumberFormatException e) {
        //do smth;
        continue;
    }
    //do smth; 
} 

如果有人知道如何解决这个问题，我会非常感谢你的建议。先谢谢你

更新 真的很抱歉，这是我的错。valueOf（null）也抛出NumberFormatException。谢谢你的评论。我目前的解决办法是：

 for (String currentString : stringsList) {
        try {
            Long.valueOf(currentString);
        } catch (NumberFormatException e) {
            if (currentString != null) {
                //do smth;
            }
            continue;         
        }
        //do smth;
 }

---

伙计，你的解释不是很清楚，但是看看你的“不那么优雅”的例子，你可以得到如下的东西。
如果所有的“//do smth；”代码都是相同的，那么就有一个通用方法，否则就单独使用，但尽量将所有通用代码保留在一个地方。您不应该有重复的代码。
如果这些代码片段可以从其他类重用，那么创建一个实用程序类并将其作为公共方法

考虑你所有的

//做smth不同

private void yourMethod(){
            for (String currentString : stringsList) {
                if (currentString == null) {
                    //do smth;
                } else{
                    try {
                        Long.valueOf(currentString);
                    } catch (NumberFormatException e) {
                        //do smth;
                        continue;
                    }
                    //do smth;
                }
            }
        }

考虑你所有的
//做smth相同

private void yourMethod(){
            for (String currentString : stringsList) {
                if (currentString == null) {
                    doSomething();
                } else{
                    try {
                        Long.valueOf(currentString);
                    } catch (NumberFormatException e) {
                        //Error handling...
                    } finally{
                        doSomething();
                    }
                }
            }
        }

        private void doSomething(){
            //do smth;
        }

伙计，你的解释不是很清楚，但是看看你的“不那么优雅”的例子，你可以得到如下的东西。

如果所有的“//do smth；”代码都是相同的，那么就有一个通用方法，否则就单独使用，但尽量将所有通用代码保留在一个地方。您不应该有重复的代码。

如果这些代码片段可以从其他类重用，那么创建一个实用程序类并将其作为公共方法

考虑你所有的
//做smth不同

private void yourMethod(){
            for (String currentString : stringsList) {
                if (currentString == null) {
                    //do smth;
                } else{
                    try {
                        Long.valueOf(currentString);
                    } catch (NumberFormatException e) {
                        //do smth;
                        continue;
                    }
                    //do smth;
                }
            }
        }

考虑你所有的
//做smth相同

private void yourMethod(){
            for (String currentString : stringsList) {
                if (currentString == null) {
                    doSomething();
                } else{
                    try {
                        Long.valueOf(currentString);
                    } catch (NumberFormatException e) {
                        //Error handling...
                    } finally{
                        doSomething();
                    }
                }
            }
        }

        private void doSomething(){
            //do smth;
        }

伙计，你的解释不是很清楚，但是看看你的“不那么优雅”的例子，你可以得到如下的东西。

如果所有的“//do smth；”代码都是相同的，那么就有一个通用方法，否则就单独使用，但尽量将所有通用代码保留在一个地方。您不应该有重复的代码。

如果这些代码片段可以从其他类重用，那么创建一个实用程序类并将其作为公共方法

考虑你所有的
//做smth不同

private void yourMethod(){
            for (String currentString : stringsList) {
                if (currentString == null) {
                    //do smth;
                } else{
                    try {
                        Long.valueOf(currentString);
                    } catch (NumberFormatException e) {
                        //do smth;
                        continue;
                    }
                    //do smth;
                }
            }
        }

考虑你所有的
//做smth相同

private void yourMethod(){
            for (String currentString : stringsList) {
                if (currentString == null) {
                    doSomething();
                } else{
                    try {
                        Long.valueOf(currentString);
                    } catch (NumberFormatException e) {
                        //Error handling...
                    } finally{
                        doSomething();
                    }
                }
            }
        }

        private void doSomething(){
            //do smth;
        }

伙计，你的解释不是很清楚，但是看看你的“不那么优雅”的例子，你可以得到如下的东西。

如果所有的“//do smth；”代码都是相同的，那么就有一个通用方法，否则就单独使用，但尽量将所有通用代码保留在一个地方。您不应该有重复的代码。

如果这些代码片段可以从其他类重用，那么创建一个实用程序类并将其作为公共方法

考虑你所有的
//做smth不同

private void yourMethod(){
            for (String currentString : stringsList) {
                if (currentString == null) {
                    //do smth;
                } else{
                    try {
                        Long.valueOf(currentString);
                    } catch (NumberFormatException e) {
                        //do smth;
                        continue;
                    }
                    //do smth;
                }
            }
        }

考虑你所有的
//做smth相同

private void yourMethod(){
            for (String currentString : stringsList) {
                if (currentString == null) {
                    doSomething();
                } else{
                    try {
                        Long.valueOf(currentString);
                    } catch (NumberFormatException e) {
                        //Error handling...
                    } finally{
                        doSomething();
                    }
                }
            }
        }

        private void doSomething(){
            //do smth;
        }

Long.valueOf不会抛出NullPointerException

在长源代码中，您将看到valueOf方法调用parseLong方法

此方法检查null并抛出NumberFormatException（请参阅下面的代码段）

所以你必须这么做

if (currentString == null) {
    //do smth;
    continue;
}

Long.valueOf不会抛出NullPointerException

在长源代码中，您将看到valueOf方法调用parseLong方法

此方法检查null并抛出NumberFormatException（请参阅下面的代码段）

所以你必须这么做

if (currentString == null) {
    //do smth;
    continue;
}

Long.valueOf不会抛出NullPointerException

在长源代码中，您将看到valueOf方法调用parseLong方法

此方法检查null并抛出NumberFormatException（请参阅下面的代码段）

所以你必须这么做

if (currentString == null) {
    //do smth;
    continue;
}

Long.valueOf不会抛出NullPointerException

在长源代码中，您将看到valueOf方法调用parseLong方法

此方法检查null并抛出NumberFormatException（请参阅下面的代码段）

所以你必须这么做

if (currentString == null) {
    //do smth;
    continue;
}

下一个catch块无论如何都会被执行——如果捕获到
NullPointerException
，下一个
catch
块将不会运行。您的代码很可能还有其他问题。（如果你不同意我的观点，请发一条帖子。）捕获NullPointerException是个坏主意，你的“不优雅”解决方案实际上更好。你的代码只能引发一种异常：如果你得到NPE，那么你也不能得到NFE，因此，在两个catch块中使用
continue
不会跳过任何代码。下一个catch块无论如何都会执行——如果捕获到
NullPointerException
，下一个
catch
块将不会运行。您的代码很可能还有其他问题。（如果你不同意我的观点，请发一条帖子。）捕获NullPointerException是个坏主意，你的“不优雅”解决方案实际上更好。你的代码只能引发一种异常：如果你得到NPE，那么你也不能得到NFE，因此，在两个catch块中使用
continue
不会跳过任何代码。下一个catch块无论如何都会执行——如果捕获到
NullPointerException
，下一个
catch
块将不会运行。您的代码很可能还有其他问题。（如果你不同意我的观点，请发表一篇文章。）捕获NullPointerException是个坏主意，你的“不优雅”解决方案实际上更好。你的代码只能引发一种异常：如果你得到NPE，那么你也不能有NFE，所以在两个catch bl中都使用
continue