As long as you are aware of what you need to accomplish in the loop you could put the try catch outside the loop. But it is important to understand that the loop will then end as soon as the exception occurs and that may not always be what you want. This is actually a very common error in Java based software. People need to process a number of items, such as emptying a queue, and falsely rely on an outer try/catch statement handling all possible exceptions. They could also be handling only a specific exception inside the loop and not expect any other exception to occur. Then if an exception occurs that is not handled inside the loop then the loop will be "preemted", it ends possibly prematurely and the outer catch statement handles the exception.

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

如果这是一个全有或全无的失败，那么第一种格式是有意义的。如果希望能够处理/返回所有未失败的元素，则需要使用第二种形式。这些就是我选择方法的基本标准。就我个人而言，如果是孤注一掷，我不会使用第二种形式。

性能:

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

这里有一个参考:http://www.javaworld.com/javaworld/jw-01-1997/jw-01-hood.html

这张桌子在一半的地方被描述。

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

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

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

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

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

好吧，在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客户端VM上绝对没有性能差异(我没有访问其他版本)。整个测试的总时间差在几毫秒的数量级上。

因此，唯一要考虑的是什么看起来最干净。我发现第二种方式很难看，所以我要么坚持第一种方式，要么坚持雷·海耶斯的方式。