应该尝试在循环内部或外部进行捕获？

https://stackoverflow.com/questions/141560

02-07-2019
|

题

我有一个看起来像这样的循环：

for (int i = 0; i < max; i++) {
    String myString = ...;
    float myNum = Float.parseFloat(myString);
    myFloats[i] = myNum;
}

这是方法的主要内容，其唯一目的是返回浮点数组。如果出现错误，我希望此方法返回 null ，因此我将循环放在 try ... catch 块中，如下所示：

try {
    for (int i = 0; i < max; i++) {
        String myString = ...;
        float myNum = Float.parseFloat(myString);
        myFloats[i] = myNum;
    }
} catch (NumberFormatException ex) {
    return null;
}

但后来我还考虑将 try ... catch 块放在循环中，如下所示：

for (int i = 0; i < max; i++) {
    String myString = ...;
    try {
        float myNum = Float.parseFloat(myString);
    } catch (NumberFormatException ex) {
        return null;
    }
    myFloats[i] = myNum;
}

是否有任何理由，表现或其他方式优先于另一方？

编辑：一致认为，将循环置于try / catch中可能更清晰，可能在其自己的方法中。但是，关于哪个更快，仍然存在争议。有人可以对此进行测试，并以统一的答案回来吗？

解决方案 3

好的， Jeffrey L Whitledge说没有性能差异（截至1997年），我去测试了它。我跑了这个小基准：

public class Main {

    private static final int NUM_TESTS = 100;
    private static int ITERATIONS = 1000000;
    // time counters
    private static long inTime = 0L;
    private static long aroundTime = 0L;

    public static void main(String[] args) {
        for (int i = 0; i < NUM_TESTS; i++) {
            test();
            ITERATIONS += 1; // so the tests don't always return the same number
        }
        System.out.println("Inside loop: " + (inTime/1000000.0) + " ms.");
        System.out.println("Around loop: " + (aroundTime/1000000.0) + " ms.");
    }
    public static void test() {
        aroundTime += testAround();
        inTime += testIn();
    }
    public static long testIn() {
        long start = System.nanoTime();
        Integer i = tryInLoop();
        long ret = System.nanoTime() - start;
        System.out.println(i); // don't optimize it away
        return ret;
    }
    public static long testAround() {
        long start = System.nanoTime();
        Integer i = tryAroundLoop();
        long ret = System.nanoTime() - start;
        System.out.println(i); // don't optimize it away
        return ret;
    }
    public static Integer tryInLoop() {
        int count = 0;
        for (int i = 0; i < ITERATIONS; i++) {
            try {
                count = Integer.parseInt(Integer.toString(count)) + 1;
            } catch (NumberFormatException ex) {
                return null;
            }
        }
        return count;
    }
    public static Integer tryAroundLoop() {
        int count = 0;
        try {
            for (int i = 0; i < ITERATIONS; i++) {
                count = Integer.parseInt(Integer.toString(count)) + 1;
            }
            return count;
        } catch (NumberFormatException ex) {
            return null;
        }
    }
}

我使用javap检查了生成的字节码，以确保没有任何内联。

结果显示，假设JIT优化不明显， Jeffrey是正确的; Java 6，Sun客户端虚拟机绝对没有性能差异（我没有访问其他版本）。在整个测试中，总时间差大约为几毫秒。

因此，唯一的考虑因素是看起来最干净。我发现第二种方式是丑陋的，所以我会坚持第一种方式或 Ray Hayes的方式。

其他提示

性能：

try / catch结构的放置位置绝对没有性能差异。在内部，它们被实现为在调用方法时创建的结构中的代码范围表。当方法正在执行时，除非发生抛出，否则try / catch结构完全不在图片中，然后将错误的位置与表进行比较。

以下是参考资料： http：// www。 javaworld.com/javaworld/jw-01-1997/jw-01-hood.html

该表描述了一半。

效果：正如 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

你有很大的不同：

在try / catch中突破循环

尝试/捕捉，同时保持循环活动

我同意所有的性能和可读性帖子。但是，有些情况确实很重要。其他几个人提到了这一点，但通过示例可能更容易看到。

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

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

如前所述，性能是相同的。但是，用户体验不一定相同。在第一种情况下，您将快速失败（即在第一次错误之后），但是如果将try / catch块放在循环中，则可以捕获为给定方法调用创建的所有错误。在从期望出现格式错误的字符串解析值的数组时，肯定会有这样的情况：您希望能够将所有错误呈现给用户，这样他们就不需要逐个尝试修复它们

如果它是全有或全无失败，那么第一种格式是有意义的。如果您希望能够处理/返回所有非故障元素，则需要使用第二种形式。那些将是我在方法之间进行选择的基本标准。就个人而言，如果是全有或全无，我就不会使用第二种形式。

只要你知道你需要在循环中完成什么，就可以把try catch放在循环之外。但重要的是要理解，一旦异常发生，循环就会结束，并且可能并不总是你想要的。这实际上是基于Java的软件中非常常见的错误。人们需要处理许多项目，例如清空队列，并错误地依赖处理所有可能异常的外部try / catch语句。它们也可以只处理循环内的特定异常，而不期望发生任何其他异常。然后，如果发生在循环内未处理的异常，则循环将被“预先”，它可能过早地结束，外部catch语句处理异常。

如果循环在生命中扮演了清空队列的角色，那么该循环很可能在该队列被清空之前结束。很常见的错误。

在您的示例中，没有功能差异。我发现你的第一个例子更具可读性。

您应该更喜欢外部版本而不是内部版本。这只是规则的特定版本，移动循环外的任何东西，你可以移动到循环外。根据IL编译器和JIT编译器，您的两个版本可能会或可能不会以不同的性能特征结束。

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

如果将try / catch放在循环中，则会在异常后继续循环。如果你把它放在循环外面，你会在抛出异常时立即停止。

我的观点是try / catch块是确保正确异常处理所必需的，但创建此类块会影响性能。由于，循环包含密集的重复计算，因此不建议将try / catch块放在循环中。另外，似乎在这种情况发生的地方，它通常是“例外”。或“RuntimeException”被抓住了。应避免在代码中捕获RuntimeException。同样，如果您在大公司工作，则必须正确记录该异常，或者停止发生运行时异常。这个描述的全部内容是请尽量避免使用TRY-CATCH BLOCKS

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

取决于迭代次数，性能差异可能微不足道。

但是我同意其他人认为在循环之外使循环体看起来更清洁。

如果有可能你想继续处理而不是退出，如果有一个无效的数字，那么你会希望代码在循环内。

如果它在里面，那么你将获得尝试/捕获结构的开销N次，而不是只在外面一次。

每次调用Try / Catch结构时，都会增加方法执行的开销。只是一点点记忆和处理结构所需的处理器滴答。如果你正在运行一个循环100次，并且为了假设的缘故，假设每次尝试/捕获调用的成本是1个滴答，那么在循环内部使用Try / Catch会花费100个滴答，而不是只有1个滴答，如果它是在循环之外。

异常的全部意义在于鼓励第一种方式：让错误处理得到整合和处理一次，而不是立即在每个可能的错误站点处进行。

把它放进去。您可以继续处理（如果需要），也可以抛出一个有用的异常，告诉客户端myString的值和包含错误值的数组的索引。我认为NumberFormatException已经告诉你错误的值，但原则是将所有有用的数据放在你抛出的异常中。想想在程序中此时调试器中你会感兴趣的内容。

考虑一下：

try {
   // parse
} catch (NumberFormatException nfe){
   throw new RuntimeException("Could not parse as a Float: [" + myString + 
                              "] found at index: " + i, nfe);
}

在需要的时候，你会非常感谢这样的例外，尽可能多地提供信息。

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

“更广泛”的 try-catch 块的责任（即在你的情况下在循环之外）意味着在稍后更改代码时，你可能会错误地添加一条由现有处理的行catch 块;可能是无意的。在您的情况下，这不太可能，因为您明确捕获 NumberFormatException
“更窄”的 try-catch 块的责任，重构变得越困难。特别是在（如你的情况下）你正在执行“非本地”的情况时。来自 catch 块内的指令（ return null 语句）。

这取决于故障处理。如果您只想跳过错误元素，请尝试在内部：

for(int i = 0; i < max; i++) {
    String myString = ...;
    try {
        float myNum = Float.parseFloat(myString);
        myFloats[i] = myNum;
    } catch (NumberFormatException ex) {
        --i;
    }
}

在任何其他情况下，我更喜欢在外面尝试。代码更易读，更干净。也许最好在错误情况下抛出IllegalArgumentException而不是返回null。

我会把我的0.02美元投入。有时你最终需要添加一个“终于”。稍后在您的代码中（因为谁第一次完美地编写代码？）。在这些情况下，突然将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都会对堆栈产生某些影响，这可能会对递归方法产生影响。

如果方法“外（）”，调用方法“inner（）” （可以递归地调用自己），尝试在方法“outer（）”中找到try-catch。如果可能的话。一个简单的“堆栈崩溃”我们在性能类中使用的示例在try-catch在内部方法中时大约为6,400帧，在外部方法中大约为11,600。

在现实世界中，如果您使用复合模式并且具有大而复杂的嵌套结构，则可能会出现问题。

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

如果你想打破循环并在每次抛出时检查Exception，请使用try ... catch out of the loop。这将在catch（如果有）之后中断循环并执行语句。

这一切都取决于你的需要。我更喜欢在部署时使用try ... catch循环，如果发生Exception，结果不会模糊，循环不会中断并完全执行。

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow