如果你想在每个迭代中捕获Exception，或者检查哪个迭代抛出了Exception，并捕获迭代中的每个Exception，放置try…在循环内捕获。如果发生异常，这将不会中断循环，并且您可以在整个循环的每次迭代中捕获每个异常。

如果你想打破循环并在抛出异常时检查异常，请使用try…从循环中捕获。这将打破循环并在catch(如果有的话)之后执行语句。

这完全取决于你的需要。我更喜欢用try…如果Exception发生，结果不会有歧义，并且循环不会中断并完全执行。

我想添加我自己的0.02c，关于在哪里放置异常处理的一般问题时两个相互竞争的考虑因素:

The "wider" the responsibility of the try-catch block (i.e. outside the loop in your case) means that when changing the code at some later point, you may mistakenly add a line which is handled by your existing catch block; possibly unintentionally. In your case, this is less likely because you are explicitly catching a NumberFormatException The "narrower" the responsibility of the try-catch block, the more difficult refactoring becomes. Particularly when (as in your case) you are executing a "non-local" instruction from within the catch block (the return null statement).

我同意所有关于性能和可读性的帖子。然而，在某些情况下，这确实很重要。其他一些人也提到了这一点，但通过例子可能更容易理解。

考虑这个稍微修改过的例子:

public static void main(String[] args) {
    String[] myNumberStrings = new String[] {"1.2345", "asdf", "2.3456"};
    ArrayList asNumbers = parseAll(myNumberStrings);
}

public static ArrayList parseAll(String[] numberStrings){
    ArrayList myFloats = new ArrayList();

    for(int i = 0; i < numberStrings.length; i++){
        myFloats.add(new Float(numberStrings[i]));
    }
    return myFloats;
}

如果你想让parseAll()方法在有任何错误时返回null(就像原来的例子一样)，你可以把try/catch放在外面，像这样:

public static ArrayList parseAll1(String[] numberStrings){
    ArrayList myFloats = new ArrayList();
    try{
        for(int i = 0; i < numberStrings.length; i++){
            myFloats.add(new Float(numberStrings[i]));
        }
    } catch (NumberFormatException nfe){
        //fail on any error
        return null;
    }
    return myFloats;
}

实际上，您可能应该在这里返回一个错误，而不是null，通常我不喜欢有多个返回，但您可以理解。

另一方面，如果你想让它忽略问题，并解析任何它能解析的字符串，你可以把try/catch放在循环的内部，像这样:

public static ArrayList parseAll2(String[] numberStrings){
    ArrayList myFloats = new ArrayList();

    for(int i = 0; i < numberStrings.length; i++){
        try{
            myFloats.add(new Float(numberStrings[i]));
        } catch (NumberFormatException nfe){
            //don't add just this one
        }
    }

    return myFloats;
}

虽然性能可能是相同的，“看起来”更好的是非常主观的，但在功能上仍然有相当大的差异。举个例子:

Integer j = 0;
    try {
        while (true) {
            ++j;

            if (j == 20) { throw new Exception(); }
            if (j%4 == 0) { System.out.println(j); }
            if (j == 40) { break; }
        }
    } catch (Exception e) {
        System.out.println("in catch block");
    }

while循环位于try catch块内，变量'j'将递增到40，当j mod 4为零时输出，当j达到20时抛出异常。

在详细介绍之前，先来看另一个例子:

Integer i = 0;
    while (true) {
        try {
            ++i;

            if (i == 20) { throw new Exception(); }
            if (i%4 == 0) { System.out.println(i); }
            if (i == 40) { break; }

        } catch (Exception e) { System.out.println("in catch block"); }
    }

与上面的逻辑相同，唯一不同的是try/catch块现在在while循环中。

下面是输出(在try/catch中):

4
8
12 
16
in catch block

而另一个输出(try/catch in while):

4
8
12
16
in catch block
24
28
32
36
40

这里有很大的不同:

While in try/catch跳出循环

Try /catch in while保持循环活动

为try/catch设置一个特殊的堆栈框架会增加额外的开销，但是JVM可能能够检测到您正在返回并优化它。

根据迭代次数的不同，性能差异可能可以忽略不计。

然而，我同意其他人的观点，把它放在循环之外会让循环体看起来更干净。

如果您希望继续处理，而不是在存在无效数字时退出，那么您将希望代码位于循环中。

上面没有提到的另一个方面是，每个try-catch都会对堆栈产生一些影响，这可能会对递归方法产生影响。

如果方法"outer()"调用方法"inner()"(它可能递归地调用自己)，如果可能的话，尝试在方法"outer()"中找到try-catch。我们在性能类中使用的一个简单的“堆栈崩溃”示例，当try-catch在内部方法中时，在大约6400帧时失败，当它在外部方法中时，在大约11,600帧时失败。

在现实世界中，如果您正在使用Composite模式并且具有大型、复杂的嵌套结构，这可能会成为一个问题。