嵌套For循环性能优化分析

1、案例描述

某日，在JavaEye上看到一道面试题，题目是这样的：请对以下的代码进行优化

[java] view plain copy print ?

1. for (int i = 0; i < 1000; i++)  
2.     for (int j = 0; j < 100; j++)  
3.         for (int k = 0; k < 10; k++)  
4.             testFunction (i, j, k);  

2、案例分析

从上述代码案例可以看出，不论如何优化，testFunction()执行的次数都是相同的，该部分是不存在优化的可能。那么优化只能从循环变量i,j,k的实例化、初始化、比较、自增等耗时方面来进行分析。首先，分析原题代码循环变量在以上方面的耗时情况：

变量	实例化（次数）	初始化（次数）	比较（次数）	自增（次数）
i	1	1	1000	1000
j	1000	1000	1000*100	1000*100
k	1000*100	1000*100	1000*100*10	1000*100*10

目的： 该代码性能优化就是要尽可能地减少循环变量i、j、k的实例化、初始化、比较、自增的次数，同时不引起其他可能的耗时运算。

3、解决过程

优化方案①：

[java] view plain copy print ?

1. for (int i = 0; i < 10; i++)  
2.     for (int j = 0; j < 100; j++)  
3.         for (int k = 0; k < 1000; k++)  
4.             testFunction (k, j, i);  

该方案主要是将循环次数少的放在外面，循环次数多的放在里层，这样可以最大程度地减少相关循环变量的实例化次数、初始化次数等，方案耗时情况如下：

变量	实例化（次数）	初始化（次数）	比较（次数）	自增（次数）
i	1	1	10	10
j	10	10	10*100	10*100
k	10*100	10*100	10*100*1000	10*100*1000

优化方案②：

[java] view plain copy print ?

1. int i, j, k;  
2. for (i = 0; i < 10; i++)  
3.     for (j = 0; j < 100; j++)  
4.         for (k = 0; k < 1000; k++)  
5.             testFunction (k, j, i);  

该方案主要是在方案①的基础上，将循环变量的实例化放在循环外，这样可以进一步减少实例化次数，耗时情况如下表：

变量	实例化（次数）	初始化（次数）	比较（次数）	自增（次数）
i	1	1	10	10
j	1	10	10*100	10*100
k	1	10*100	10*100*1000	10*100*1000

注：方案②的优势体现在若将i、j、k的数值提高更多的，其提升的效果才更明显。

4、测试代码

[java] view plain copy print ?

1. public class Test {  
2.     public static void main(String[] args){  
3. //      testA();  
4. //      testB();  
5.         testC();  
6.     }  
7.       
8.     public static void testA(){  
9.         long start = System.nanoTime();  
10.         for(int i = 0; i < 10; i++)  
11.             for(int j = 0; j < 1000; j++)  
12.                 for(int k = 0; k < 10000; k++)  
13.                     ;  
14.         System.out.println("testA time>>"+(System.nanoTime()-start)+"ns");  
15.     }  
16.       
17.     public static void testB(){  
18.         long start = System.nanoTime();  
19.         for(int i = 0; i < 10000; i++)  
20.             for(int j = 0; j < 1000; j++)  
21.                 for(int k = 0; k < 10; k++)  
22.                     ;  
23.         System.out.println("testB time>>"+(System.nanoTime()-start)+"ns");  
24.     }  
25.       
26.     public static void testC(){  
27.         long start = System.nanoTime();  
28.         int i, j, k;  
29.         for(i = 0; i < 10; i++)  
30.             for(j = 0; j < 1000; j++)  
31.                 for(k = 0; k < 10000; k++)  
32.                     ;  
33.         System.out.println("testC time>>"+(System.nanoTime()-start)+"ns");  
34.     }  
35. }