在有的文章中，关于Java代码优化有这么一条：

【【不要在循环中使用 try-catch，应该把其放在最外层。】】

我是怀疑的，然后，今天就来实际测试一下。看看是不是真的像这条建议所言，真的有优化效果。不能以讹传讹，假的都成真的啦

使用JProfiler来测试一下，OK，let's go。开始测试；

第一次测试：

package com.lxk.fast; 
 
import com.lxk.model.Dog; 
 
/** 
 * 据说 try catch 在for循环体中会影响效率，不服来测测。 
 * 
 * @author LiXuekai on 2019/7/19 
 */ 
public class TryCatchIsFastInOrOutFor { 
    private static final int FOR_MAX = 1000; 
    private static final int FOR_MAX_ = 999; 
 
    public static void main(String[] args) { 
        test(); 
    } 
 
    private static void test() { 
        while (true) { 
            //testNoException(); 
            testException(); 
        } 
    } 
 
    /** 
     * 在 try catch 中【会】抛异常 
     */ 
    private static void testException() { 
        out(); 
        in(); 
    } 
 
    /** 
     * 在try catch 中【不会】抛异常 
     */ 
    private static void testNoException() { 
        inNoException(); 
        outNoException(); 
    } 
 
    private static void in() { 
        int i = 0; 
        while (i < FOR_MAX) { 
            try { 
                Dog dog = new Dog(); 
                //确保最后一次抛异常，大家循环次数一致 
                if (i == FOR_MAX_) { 
                    throw new Exception("xxxxxxxxx"); 
                } 
            } catch (Exception e) { 
            } 
            i++; 
        } 
    } 
 
    private static void out() { 
        int i = 0; 
        try { 
            while (i < FOR_MAX) { 
                Dog dog = new Dog(); 
                //确保最后一次抛异常，大家循环次数一致 不能上来就抛异常，那么这个循环次数就比上面少了。 
                if (i == FOR_MAX_) { 
                    throw new Exception("xxxxxxxxx"); 
                } 
                i++; 
            } 
        } catch (Exception e) { 
        } 
 
    } 
 
    private static void outNoException() { 
        int i = 0; 
        try { 
            while (i < FOR_MAX) { 
                Dog dog = new Dog(); 
                if (i == FOR_MAX_) { 
                    new Exception("xxxxxxxxx"); 
                } 
                i++; 
            } 
        } catch (Exception e) { 
        } 
    } 
 
    private static void inNoException() { 
        int i = 0; 
        while (i < FOR_MAX) { 
            try { 
                Dog dog = new Dog(); 
                if (i == FOR_MAX_) { 
                    new Exception("xxxxxxxxx"); 
                } 
            } catch (Exception e) { 
            } 
            i++; 
        } 
    } 
} 

测试效果如下：

代码解释一下：

2个方法的执行次数，咱先保证一致，在最后一次的时候，抛异常，使得测试环境一致，结果才不会太尴尬。

上面测试的是代码在循环的时候真的抛异常啦，在抛异常的情况下，看看效率比。

结果：

发现，结果是差不多的嘛，五五开嘛，差距0.3%，太小了，忽略吧。

第二次测试：

使用第一个方法，走不抛异常的情况下，看看这个try catch 在里面和在外边 有没有太大的差别。

结果：

结果对比，差距0.9%，在循环里面的时候，这个Dog在构造对象的时候，多花了0.4%。这是为啥呢？

总的来说：

这2个的差距，并没有可观的性能提升，，，，，SO，

【【不要在循环中使用 try-catch，应该把其放在最外层。】】

这个理论，是扯犊子的嘛，都以讹传讹的，说这个姿势可以优化代码，然后就这么写了，都不带实际测试的，别人说啥就是啥。

还有就是，在这个循环过程中，你要是try catch 写在外边，那么循环里面一旦异常，这个循环就gg了，估计这不是你的意图吧，我既然循环，那肯定是有的是可以成功的，不是说一个异常了，就全完蛋了。不能这么干吧。

所以，再次说明，当初总结这个理论的人，完全是扯犊子的。写在外边，是影响正常代码逻辑的。不OK的。

我反对?‍♂️。