關於對For循環嵌套優化的問題

1.案例描述

因爲一次Java面試的筆試題，當時沒有寫出很好的解決方案，特此專門撰寫一篇博客來加以記錄，方便往後的查看

面試題目以下：從性能上優化以下代碼並說明優化理由？

 

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             System.out.println(i+""+j+""+k);
5          }
6     }
7 }

View Code

 

2.案例分析

從給出的代碼可知，不論如何優化，testFunction執行的次數都是相同的，該部分不存在優化的可能。那麼，代碼的優化只能從循環變量i、j、k的實例化、初始化、比較、自增等方面的耗時上進行分析。
首先，咱們先分析原題代碼循環變量在實例化、初始化、比較、自增等方面的耗時狀況：

變量	實例化(次數)	初始化(次數)	比較(次數)	自增(次數)
i	1	1	1000	1000
j	1	1000	1000 * 100	1000*100
k	1	1000*100	1000 * 100 * 10	1000 * 100 * 10

 

 

 

 

（注：因爲單次耗時視不一樣機器配置而不一樣，上表相關耗時採用處理的次數進行說明）
該代碼的性能優化就是儘量減小循環變量i、j、k的實例化、初始化、比較、自增的次數，同時，不能引進其它可能的運算耗時。)

3.解決過程

從案例分析，對於原題代碼，咱們提出有兩種優化方案：

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                 System.out.println(i+""+j+""+k);
5            }
6       }
7 }    

View Code

該方案主要是將循環次數最少的放到外面，循環次數最多的放裏面，這樣能夠最大程度的（注：3個不一樣次數的循環變量共有6種排列組合狀況，此種組合爲最優）減小相關循環變量的實例化次數、初始化次數、比較次數、自增次數，方案耗時狀況以下：

變量	實例化(次數)	初始化(次數)	比較(次數)	自增(次數)
i	1	1	10	10
j	10	10	10*100	10 * 100
k	10*100	10*100	10 * 100 * 1000	10 * 100 * 1000

 

 

 

 

3.2 優化方案二 
代碼以下： 

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             System.out.println(i+" "+j+" "+k);    
6         }
7     }
8 }

該方案在方案一的基礎上，將循環變量的實例化放到循環外，這樣能夠進一步減小相關循環變量的實例化次數，方案耗時狀況以下： 

變量	實例化(次數)	初始化(次數	比較(次數)	自增(次數)
i	1	1	10	10
j	1	10	10*100	10*100
k	1	10*100	10*100*1000	10*100*1000

 

 

 

4 解決結果 
那麼，提出的優化方案是否如咱們分析的那樣有了性能上的提高了呢？咱們編寫一些測試代碼進行驗證，數據更能說明咱們的優化效果。 
4.1 測試代碼 

 1 public static void testFunction(int i, int j, int k) {  
 2         System.out.print("");   // 注：該方法不影響總體優化，這裏只有簡單輸出  
 3     }  
 4   
 5     public static void testA() {  
 6         long start = System.nanoTime();  
 7         for (int i = 0; i < 1000; i++)  
 8             for (int j = 0; j < 100; j++)  
 9                 for (int k = 0; k < 10; k++)  
10                     testFunction(i, j, k);  
11         System.out.println("testA time>>" + (System.nanoTime() - start));  
12     }  
13   
14     public static void testB() {  
15         long start = System.nanoTime();  
16         for (int i = 0; i < 10; i++)  
17             for (int j = 0; j < 100; j++)  
18                 for (int k = 0; k < 1000; k++)  
19                     testFunction(k, j, i);  
20         System.out.println("testB time>>" + (System.nanoTime() - start));  
21     }  
22   
23     public static void testC() {  
24         long start = System.nanoTime();  
25         int i;  
26         int j;  
27         int k;  
28         for (i = 0; i < 10; i++)  
29             for (j = 0; j < 100; j++)  
30                 for (k = 0; k < 1000; k++)  
31                     testFunction(k, j, i);  
32         System.out.println("testC time>>" + (System.nanoTime() - start));  
33 }  

4.2 測試結果 
一、測試機器配置：Pentium(R) Dual-Core CPU E5400 @2.70GHz 2.70GHz, 2GB內存； 
二、循環變量i、j、k循環次數分別爲十、100、1000，進行5組測試，測試結果以下： 

	第1組	第2組	第3組	第4組	第5組
原方案	171846271	173250166	173910870	173199875	173725328
方案一	168839312	168466660	168372616	168310190	168041251
方案二	168001838	169141906	168230655	169421766	168240748

 

 

 

從上面的測試結果來看，優化後的方案明顯性能優於原方案，達到了優化的效果。但優化方案二並無如咱們預期的優於方案一，其中第二、四、5組的數據更是比方案一差，懷疑多是循環次數太少，以及測試環境相關因素影響下出現的結果。 

三、從新調整循環變量i、j、k循環次數分別爲20、200、2000，進行5組測試，測試結果以下：

	第1組	第2組	第3組	第4組	第5組
原方案	1355397203	1358978176	1358128281	1350193682	1354786598
方案一	1343482704	1348410388	1343978037	1347919156	1340697793
方案二	1342427528	1343897887	1342662462	1342124048	1336266453

 

 

 

從上面的測試結果來看，優化後的方案基本符合咱們的預期結果。 

5 總結 從案例分析和解決過程當中的三個表的分析可知，優化方案一和優化方案二的性能都比原代碼的性能好，其中優化方案二的性能是最好的。在嵌套For循環中，將循環次數多的循環放在內側，循環次數少的循環放在外側，其性能會提升；減小循環變量的實例化，其性能也會提升。從測試數據可知，對於兩種優化方案，若是在循環次數較少的狀況下，其運行效果區別不大；但在循環次數較多的狀況下，其效果就比較明顯了。