1. int v1=100000;
   
2.         int v2=10000;
   
3.         int v3=10;
   
4.         for(int i=0; i<v1;i++)
   
5.                 for(int j=0; j<v2; j++)
   
6.                         for(int k=0; k<v3; k++)
   
7.                                 do();
   
8. 
   
9. 
   
10. for(int i=0; i<v3;i++)
    
11.                 for(int j=0; j<v2; j++)
    
12.                         for(int k=0; k<v1; k++)
    
13.                                 do();

复制代码

这两个循环哪个效率高 ， 为什么？？

直觉是第二种。{:soso_e100:}
但是经过测试，似乎直觉不靠谱。
第一种

1. public class ForCompare {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                 long all=0;
   
9.                 long allTime=0;
   
10.                 while(all<50){
    
11.                     int v1=100;
    
12.                 int v2=10;
    
13.                 int v3=1;
    
14.                 long l2=System.currentTimeMillis();
    
15.        
    
16.        
    
17.                for(int i=0; i<v1;i++){
    
18.                        for(int j=0; j<v2; j++){
    
19.                                for(int k=0; k<v3; k++){
    
20.                                       
    
21.                                        AAA();
    
22.                                }
    
23.                        }
    
24.                }
    
25.                 long l3=System.currentTimeMillis();
    
26.                
    
27.                 System.out.println(l3 - l2);
    
28.                 all++;
    
29.                 allTime+=l3 - l2;
    
30.                 
    
31.                 }
    
32. 
    
33.                 System.out.println(allTime);
    
34.                 //51906
    
35.                 //593
    
36.                 //250,266,266,250,250
    
37.                 //1062,1172,1094,1125,1062,1094,1047,1110,1063,1156,1093
    
38.         }
    
39.         public static void AAA(){
    
40.                 for (int i = 0; i < 2; i++) {
    
41.                         System.out.println("hehe");
    
42.                        
    
43.                 }
    
44.         }
    
45. 
    
46. }

复制代码

第二种

1. public class CopyOfForCompare1 {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                
   
9.         long all=0;
   
10.         long allTime=0;
    
11.         while(all<50){
    
12.             int v1=100;
    
13.         int v2=10;
    
14.         int v3=1;
    
15.         long l2=System.currentTimeMillis();
    
16. 
    
17. 
    
18.         for(int i=0; i<v3;i++){
    
19.                 for(int j=0; j<v2; j++){
    
20.                         for(int k=0; k<v1; k++){
    
21.                                
    
22.                                 AAA();
    
23.                         }}}
    
24.         long l3=System.currentTimeMillis();
    
25.       
    
26.         System.out.println(l3 - l2);
    
27.         all++;
    
28.         allTime+=l3 - l2;
    
29.         
    
30.         }
    
31. 
    
32.         System.out.println(allTime);
    
33.         //54234
    
34.         //625
    
35.         //234,265,250,266,266
    
36.         //1141,1125,1156,1109,1094,1141,1156,1141,1031,1109
    
37. }
    
38. public static void AAA(){
    
39.         for (int i = 0; i < 2; i++) {
    
40.                 System.out.println("hehe");
    
41.                
    
42.         }
    
43. }
    
44. 
    
45. }
    

复制代码

下面的那些注释为修改v1,v2,v3,all之后得到的结果。

循环次数一样，理论上来说效率都是一样的低，时间复杂度为O（n^3）么。
我将lz的v1改成1000，v2 改成100，测试过时间确实差别不大
当然一般情况下写代码遵循的原则是外层循环数字小，内层循环数字大的原则，至于为什么，好像和cpu的catch命中率之类的有关系
lz可以看下这篇帖子http://topic.csdn.net/u/20071206/20/5ae1a8f9-fab5-443c-a2ea-af1d755f5de1.html
我个人觉得基本上对for循环的效率不是我们需要太过关心的东西，不如想想怎么样避免使用三重for比较靠谱。

第一种的时间复杂度为：O(v1v2v3);
第二中的时间复杂度是：O(v3v2v1);
又因为：v1v2v3=v3v2v1；
所以他们的时间复杂度一样，
所以他们的循环效率相等。

第1种:循环次数为V1*V2*V3
第2种:循环次数为V3*V2*V1
SO,一样的.
就像楼上说的,研究这个不如想想怎么样避免使用三重for比较靠谱。

第二种 做过测试了 呵呵
代码改了下

public class TestFor {

        /**
         * @param args
         */
public static void main(String[] args) {
        int v1=100;
        int v2=10;
        int v3=1;
        long time1start=System.currentTimeMillis();
      
        for(int i=0; i<v1;i++)
                for(int j=0; j<v2; j++)
                        for(int k=0; k<v3; k++)
                               System.out.print("hello");
        System.out.println();
        long time1end=System.currentTimeMillis();
        System.out.println((time1end-time1start)+"millis");

        long time2start=System.currentTimeMillis();
        for(int i=0; i<v3;i++)
                for(int j=0; j<v2; j++)
                        for(int k=0; k<v1; k++)
                                System.out.print("world");

        System.out.println();
        long time2end=System.currentTimeMillis();
        System.out.println((time2end-time2start)+"millis");
        }

}
反复运行证明第二种效率明显高于第一种

效率是什么？我们先把效率在java中的意思搞清楚。效率就是java运行代码的最少个数。在这里可以指for循环的次数，当你得出的结果需要1000多循环和10个循环，你会选择哪种呢？
把代码简化一下

        for(int i=1; i<2;i++)
                for(int j=1; j<3; j++)
                        for(int k=1; k<4; k++)
                                do();


for(int i=1; i<4;i++)
                for(int j=1; j<3; j++)
                        for(int k=1; k<2; k++)
                                do();

说实话，你这个代码没有可比性，为什么，比如说通过3个for循环来去三位数，你可以发现
上面一种取的范围为111-123
而下面一种取值的范围为111-321
lz看出来了吗？没可比性。你只是单纯的在字面上理解这两个差不多，其实差很多。

ls的真牛b，明显不能比的嘛，他们取值的范围根本就不同，写了这么多完全在意淫嘛。

嗨，哥们你不妨换个角度去思考一下，他们的总循环次数是相等的你没发现吗？
v1 x  v2  x v3 = v3  x v2  x b1.
所以效率是一样的，因为总循环次数是一样的。

想这种情况只能依题而言，比如说你第一次循环就取得结果，二者没区别
你要是取221，第一个循环做不了，所以说你不知道结果的情况，效率是没可比性的。有了结果你分析二者执行了的循环循环数是不是一样的。一样的效率一样，不一样效率也不一样。

楼上的童鞋说的都挺好的

在实际的开发中，很少用三个for循环嵌套的。两个for的倒是常见。每增加一个for循环的话，效率就是低很多。虽然有时它很方便。
原因：
for循环嵌套太多的话
1.不利于代码优化，
2.效率不高

没事玩玩的for嵌套的话，相当的可以；