我把0.02美元放进去。有时，您需要在稍后的代码中添加“finally”(因为谁会在第一次就写出完美的代码呢?)在这些情况下，将try/catch放在循环之外突然变得更有意义了。例如:

try {
    for(int i = 0; i < max; i++) {
        String myString = ...;
        float myNum = Float.parseFloat(myString);
        dbConnection.update("MY_FLOATS","INDEX",i,"VALUE",myNum);
    }
} catch (NumberFormatException ex) {
    return null;
} finally {
    dbConnection.release();  // Always release DB connection, even if transaction fails.
}

因为如果出现错误，您只希望释放一次数据库连接(或选择您最喜欢的其他资源类型……)。

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

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

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

你应该喜欢外面的版本而不是里面的版本。这只是规则的一个特定版本，将任何可以移动到循环外的东西移动到循环外。根据IL编译器和JIT编译器的不同，您的两个版本最终可能具有不同的性能特征，也可能没有。

另一方面，你可能应该看看float。TryParse或Convert.ToFloat。

如果它在内部，那么您将获得N次try/catch结构的开销，而不是只在外部获得一次。

每次调用Try/Catch结构都会增加方法执行的开销。只需要处理结构所需的一点点内存和处理器节拍。如果运行一个循环100次，假设每个try/catch调用的代价是1 tick，那么在循环内执行try/catch调用的代价是100 tick，而在循环外只执行1 tick。

性能:就像Jeffrey在他的回复中所说的，在Java中这并没有太大的区别。

通常，为了代码的可读性，在哪里捕获异常的选择取决于您是否希望循环继续处理。

在您的示例中，您在捕获异常时返回。在这种情况下，我会在循环中放入try/catch。如果你只是想捕捉一个坏值，但继续处理，把它放在里面。

第三种方法:您总是可以编写自己的静态ParseFloat方法，并在该方法中而不是在循环中处理异常处理。使异常处理与循环本身隔离!

class Parsing
{
    public static Float MyParseFloat(string inputValue)
    {
        try
        {
            return Float.parseFloat(inputValue);
        }
        catch ( NumberFormatException e )
        {
            return null;
        }
    }

    // ....  your code
    for(int i = 0; i < max; i++) 
    {
        String myString = ...;
        Float myNum = Parsing.MyParseFloat(myString);
        if ( myNum == null ) return;
        myFloats[i] = (float) myNum;
    }
}

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

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保持循环活动