java for循环

①for循环

for(初始化语句；boolean表达式；循环后操作语句){

        循环体语句

}

初始化语句：只在开始循环时执行一次

boolean表达式：表达式为false是，循环终止，为true时，才执行循环体

循环后操作语句：循环每次迭代之后会调用该语句

②嵌套循环

2个人都从1数到3

        for(int count = 1;count <= 2; count ++){
            for(int num = 1;num <= 3;num ++){
                System.out.println("count:"+count+"=====num:"+num);
            }
        }
        /*
        * count:1=====num:1
        * count:1=====num:2
        * count:1=====num:3
        * count:2=====num:1
        * count:2=====num:2
        * count:2=====num:3
        * */

③嵌套循环性能优化

        for(int i = 0;i < 1000;i ++){
            for (int j = 0; j < 100; j++) {
                for (int k = 0; k < 10; k++) {
                    test(i,j,k);
                }
            }
        }

从代码上可以看到，无论如何优化，test的执行次数都是相同的，都是1000*100*10次

那么只能从循环变量i、j、k的实例化、初始化、比较、自增耗时方面进行分析，首先分析目前for循环的耗时情况

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

优化方案：减少实例化、初始化次数

        int i,j,k;
        for (i = 0; i < 10; i++) {
            for (j = 0; j < 100; j++) {
                for (k = 0; k < 1000; k++) {
                    test(i,j,k);
                }
            }        
        }

变量	实例化（次数）	初始化（次数）	比较（次数）	自增（次数）
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的实例化次数都是1，初始化次数也减少了，所以在平常的for循环时尽量减少外层循环的循环次数；

④输出矩形图案

*****

*****

*****

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println();//换行
        }

⑤输出三角形图案

*

**

***

****

*****

        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();//换行
        }

⑥输出九九乘法表

        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + i*j+"   ");
            }
            System.out.println();
        }

⑦for循环执行顺序

        for (sta1; sta2; sta3) {
            sta4
        }

①先执行sta1，做实例化和初始化；

②执行sta2，做条件判断，false/true；

③执行sta4，执行体；

④执行sta3，自增或自减；

⑤从第二步再次开始执行

⑧控制循环语句：break

求100以内，前5个3的倍数的值的和；

        int result = 0;
        int num = 0;
        for (int i = 1; i < 100; i++) {
            if(i % 3 == 0){
                result += i;
                System.out.println(i);
                num ++;
            }
            if(num == 2){
                break;
            }
        }
        System.out.println(result);

break：终止当前所在的循环，break之后的语句执行不了，对外层循环没有影响；

⑧控制循环语句：continue

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                if(j==1){
                    continue;
                }
                System.out.println(j);//continue以后的代码不会执行
            }
            System.out.println(i);
        }

continue跳出当前循环，continue之后的代码不会执行，不影响外层循环

⑨控制循环语句：return

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println(j);
                if(j==1){
                    return;
                }
                System.out.println(j);//continue以后的代码不会执行
            }
            System.out.println(i);
        }

return终止当前方法，方法终止了所以return后面的代码也不会执行了

⑩控制外层循环

    private static void test6() {
        aa:for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println(j);
                if(j==1){
                    break aa;
                }
            }
            System.out.println(i);
        }
    }

控制外层循环需要使用标签，就是给循环起个别名，别名满足标识符规则

若要控制外层循环，就在break、continue后面加上别名，如：break  <别名>