关于for循环嵌套for循环的优化问题

每天记录开发中的一个小问题

对于for循环的嵌套问题 我们常见就是这样：

for (int i = 0; i < 1000; i++){
    for (int j = 0; j < 100; j++){
        for (int k = 0; k < 10; k++){
    	system.out.println(i+"====="+j+"====="+k);
    	 }
    }
}

从上例的代码来看，我们常见的写法通常是利用if(){}、break;、continue来减少循环的次数

或者说在可以满足实际业务发展的情况之下可以将循环次数少的for循环放到外面，这样也可以减

少循环的次数

但是这些都不是我所思考的方向，我们不妨从以下几个点着重思考的方向：、

• 循环变量 i、j 、k 的实例化；
• 循环变量 i、j 、k 的初始化；
• 循环变量 i、j 、k 的自增（其实就是循环次数）；
• 循环变量 i、j 、k 的比较；

变量	实例化（次数）	初始化（次数）	比较（其实就是循环次数）	自增（次数）
i	1	1	1000	1000
j	1000	1000	1000 * 100	1000 * 100
K	1000 * 100	1000 * 100	1000 * 100 * 10	10 * 100 * 1000

代码测试（不同电脑配置测试速度也不同）：

        public static void main(String[] args) {

        long startA = System.nanoTime();
        for(int i = 0;i < 1000;i++){
            for(int j = 0;j < 100;j++){
                for(int k = 0; k < 10;k++){
                    System.out.println("如果有一天，你还会选者学Java吗？");
                }
            }
        }
        System.out.println("原始代码耗时#"+(System.nanoTime() - startA));
    }

测试次数	耗时
1	原始代码耗时： 2908737641
2	原始代码耗时：2790575343
3	原始代码耗时： 2643477965
4	原始代码耗时： 2877696520
5	原始代码耗时： 2627082670

对于以上代码的我们可以给出两种优化方案：

1. 如上所述 利用if(){}、break;、continue来减少循环的次数或者说在可以满足实际业务发展的情况之下可以将循环次数少的for循环放到外面，这样也可以减少实例化次数、初始化次数、比较次数、自增次数。

   代码如下：

for (int i = 0; i < 10; i++){
    for (int j = 0; j < 100; j++){
        for (int k = 0; k < 1000; k++){
    	system.out.println(i+"====="+j+"====="+k);
    	 }
    }
}

变量	实例化（次数）	初始化（次数）	比较（其实就是循环次数）	自增（次数）
i	1	1	10	10
j	10	10	10 * 100	10*100
K	10* 100	10 * 100	10 * 100 * 1000	10 * 100 * 1000

代码测试（不同电脑配置测试速度也不同）：

      public static void main(String[] args) {

        long startA = System.nanoTime();
        for(int i = 0;i < 10;i++){
            for(int j = 0;j < 100;j++){
                for(int k = 0; k < 1000;k++){
                    System.out.println("如果有一天，你还会选者学Java吗？");
                }
            }
        }
        System.out.println("方案一代码耗时："+(System.nanoTime() - startA));
    }

测试次数	耗时
1	方案一代码耗时： 2581724052
2	方案一代码耗时：2702852811
3	方案一代码耗时： 2470141709
4	方案一代码耗时： 2719785205
5	方案一代码耗时： 2438990457

2. 该方案在方案一的基础上，将循环变量的实例化放到循环外，这样可以进一步减少相关循环变量的实例化次数。

   代码如下：

int i,j,k;
for ( i = 0; i < 10; i++){
    for ( j = 0; j < 100; j++){
        for ( k = 0; k < 1000; k++){
    	system.out.println(i+"====="+j+"====="+k);
    	 }
    }
}

变量	实例化（次数）	初始化（次数）	比较（其实就是循环次数）	自增（次数）
i	1	1	10	10
j	1	10	10 * 100	10*100
K	1	100 * 10	10 * 100 * 1000	10 * 100 * 1000

代码测试（不同电脑配置测试速度也不同）：

       public static void main(String[] args) {

        int i, j, k;
        long startA = System.nanoTime();
        for (i = 0; i < 10; i++) {
            for (j = 0; j < 100; j++) {
                for (k = 0; k < 1000; k++) {
                    System.out.println("如果有一天，你还会选者学Java吗？");
                }
            }
        }
        System.out.println("方案二代码耗时：" + (System.nanoTime() - startA));
    }

测试次数	耗时
1	方案二代码耗时： 2545532181
2	方案二代码耗时：2696157017
3	方案二代码耗时： 2423767047
4	方案二代码耗时： 2492118852
5	方案二代码耗时： 2518746648

以上就是我们for循环的优化问题，下面我们把三次的运行结果综合到一起：

测试次数	原始代码耗时	方案一代码耗时	方案二代码耗时
1	原始代码耗时： 2908737641	方案一代码耗时: 2581724052	方案二代码耗时:2545532181
2	原始代码耗时：2790575343	方案一代码耗时：2702852811	方案二代码耗时：2696157017
3	原始代码耗时： 2643477965	方案一代码耗时： 2470141709	方案二代码耗时： 2423767047
4	原始代码耗时： 2877696520	方案一代码耗时： 2719785205	方案二代码耗时： 2492118852
5	原始代码耗时： 2627082670	方案一代码耗时： 2438990450	方案二代码耗时： 2418746648

在嵌套For循环中，将循环次数多的循环放在内侧，循环次数少的循环放在外侧，其性能会提高；减少循环变量的实例化，其性能也会提高。从测试数据可知，对于这两种优化方案或者说思考方式，如果在循环次数较少的情况下，其运行效果区别不大；但在循环次数较多的情况下，其效果就比较明显了。