for循环的经典程序分析

1.单层for循环，利用for循环打印输出1~100之间的所有整数（最基础的）然后通过与if-else语句结合实现更多的功能。
可以看出利用for循环可以遍历整数。

/*
    1. 输出从1到100之间所有的整数;(简单的单层for循环)**for循环遍历整数**
    2. 输出从1到100之间所有的奇数;(通过与if-else结合，有条件的输出语句)
    3. 输出从1到100之间所有不能被3整除的数;并输出这些整数的和;(通过增加条件，更合理的练习for循环与if语句结合)
*/
public class NumberFor {

    public static void main (String[] args) {
        //这里利用输出语句打印一个提示语句
        System.out.println("输出从1到100之间所有的整数;");
        //输出从1到100之间所有的整数;
        for (int i = 1; i < 100; i++) {
        /*
            i 为循环因子，根据题意i要初始化为1,i < 100,每个整数都要打印，因此迭代语句自增为1.
            程序执行1~100（没有100）共99次 次数：计算方法（100-1）
        */
            //循环体
            System.out.print(i + " ");
        }

        System.out.println("\n" + "输出从1到100之间所有的奇数;");
        //输出从1到100之间所有的奇数
        for (int i = 1; i < 100; i++) {
            //设置条件判断，有条件的输出循环
            if (i % 2 != 0) {
                System.out.print(i + " ");
            }
        }

        System.out.println("\n" + "输出从1到100之间所有不能被3整除的数;并输出这些整数的和");
        //输出从1到100之间所有不能被3整除的数;并输出这些整数的和
        //最后要输出整数的和，要提前声明一个保存和的变量
        int sum = 0;
        for (int i = 1; i < 100; i++) {
            if (i % 3 != 0) {
                //每次循环都进行判断，若真执行{}中语句
                System.out.print(i + " ");
                //将符合条件的i进行累加
                sum += i;
            }
        }
        System.out.println("\n" + "这些数的和为:" + sum);
    }
}

2.嵌套for循环
先利用for循环打印一个简单的矩形
矩形形式：

*****
*****
*****  每一行5个星星，共有3行

思路：若我们每次输出一行5个星星，我们循环3次就可以完成矩形

class LoopTest1 {
    public static void main(String[] args) {
        //可以称i为循环因子 需要打印3行，循环次数为3(0 1 2)在i = 3时不满足条件，结束循环。
        for (int i = 0; i < 3; i++) {
            //循环体，每次输出5个星星并换行
            System.out.println("*****");
        }
    }
}

深入思考，我们是不是也可以把每次输出5个星星这个语句转化成每次输出一个星星，循环输出5次然后构成循环。
思路：依旧用一个循环控制行数，因为每行都要输出5个星星，因此在i = 0时，它要执行一个循环输出*的循环。i = 1 i =2 都要这样，就得到下面这个嵌套循环程序

class LoopTest2{ 
    public static void main(String[] args) {
        //外循环控制行数(外循环的循环体是一个内循环)
        for (int i = 0; i < 3; j++) {
            //i ：0~3 共3次
            //内循环控制列数，这个循环用来循环输出5个星星
            for (int j = 0; j < 5; i++) {
                //内循环循环体 j：0~5 共5次 每次打印一个星星
                //这里不要换行，因为在同一行上打印
                System.out.print("*");
            }
            //内循环执行完成后进行换行
            System.out.println();
        }
    }
}

综上：若是把LoopTest1中的i < 3 ,3改为n的话就可以打印输出n行
若是把LoopTest2中的j < 5,5改为m的话每行就可以打印输出5个星星，总结一下，可以把外层循环看做控制行数，内层循环控制列数。自己多做几个程序，多思考几次就可以体会到这句话真正的含义了。
那么打印一个n*m的矩形易如反掌，下面是打印n*m矩形的程序。

class LoopTest3{

    public static void main(String[] args) {
        //从命令行获取n，m
        int n = Integer.parseInt(args[0]);
        int m = Integer.parseInt(args[1]);
        //外循环控制行数
        for (int i = 0; i < n; i++) {
            //外循环控制列数
            for (int j = 0; j < m; j++) {
                System.out.print("*");
            }
            //内层循环执行完后，进行换行
            System.out.println();
        }
    }
}

熟练掌握for嵌套循环可以打印一个空心矩形，下面代码供参考。

/**
    打印n*m的空心矩形
*/
public class TestFor {

    public static void main(String[] args) {
        //从命令行获取n，m
        int n = Integer.parseInt(args[0]);
        int m = Integer.parseInt(args[1]);

        for (int i = 0; i < n; i++) {
            //将首尾行与其他行分开打印
            if (i == 0 || i == n-1) {
                //打印首尾行
                for (int j = 0; j < m; j++){
                    System.out.print("*");
                }
            }else {
                //打印其他行
                for (int j = 0; j < m; j++) {
                    //其他行，控制首列和尾列的打印
                    if(j == 0 || j == m-1) {
                        System.out.print("*");
                    }else {
                        System.out.print(" ");
                    }
                }
            }
            System.out.println();
        }
    }
}

3.嵌套循环深入

/*
分析过程：
    打印等腰三角形(高度为5)
    底边长度为9     1 3 5 7 9 
    空格数 i            *
        4  0    *       1    
        3  1   ***      3
        2  2  *****     5
        1  3 *******    7
        0  4*********   9

        * = 2i + 1      *与行数成正比     y=kx+b
     空格 = 4-i = 5-1-i 空格与行数成反比

*/
public class TestFor {

    public static void main(String[] args) {

        for(int i = 0; i < 5; i++) {
            //从0行开始
        //程序顺序执行，先打空格，空格与行数的关系 5-1-i//5-(i+1)
            //这里j因为不在同一个{}中，所以都可以用j
            for(int j = 0; j < (5 - 1) - i; j++) {
                System.out.print(" ");
            }
            //星星打印数1 3 5 7 9 与行数关系(2*行数)+1
            for (int j = 0; j < (2 * i) + 1; j++) {
                    System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }
}
/*
    拓展一下，打印高度为n的等腰三角形
    实际只需要将外层循环5换成n就好
*/
class TestFor1 {
    public static void main(String[] args) {
        //从命令行获取参数
        int n = Integer.parseInt(args[0]);
        //设置外循环控制行数
        for (int i = 0; i < n; i++) {
            //设置内循环控制列中空格的打印
            for (int j = 0; j < n - 1 - i; j++) {
                System.out.print(" ");
            }
            //设置并列内循环控制列中*的打印
            for (int j = 0; j < (2 * i) + 1; j++) {
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }
}

总结：要想使用好循环，首先要观察问题的规律，找出要循环的步骤，直接套用即可。多做循环的题体会循环。

4.嵌套循环中最高难度的for循环问题（打印质数的问题）

首先要了解质数的定义，质数：只能被1和其本身整除的数就是质数。1不是质数

从定义可以知道，若是我们正向考虑，问题极为的复杂，要先找出其所有能被整除的数，然后判断除了1和它本身以外还有其他的吗？若有不是质数，若没有，就是质数。
这样，我们反向考虑，问题就变得异常简单。

思路：首先我们要会遍历一个范围内的整数，这个利用简单的单层循环实现，其次对于每一个整数，我们先假设它是质数，然后利用反证法只要找出一个能被它整除的数就可以将它推翻。若找不出能被它整除的数，则它是质数。

/*
    打印100-200之间的所有质数，并统计个数
    这个题，共有两个问题。
    1.打印100~200所有质数
    2.统计质数的个数

    思路：利用反证法
        质数的个数统计应该和质数输出在同一个{}中
*/
class TestFor1 {
    public static void main(String[] args) {
        //设置计数器，用于统计质数的个数
        int count = 0;
        //利用for循环遍历100~200所有整数，不包括200.
        for (int i = 100; i < 200; i++) {
            //先假设i为质数，利用反证法 设置一个布尔变量，值为true时为质数，值为false时，不是质数
            boolean flag = true;
            //设置内循环对每个数进行判断
            //质数：只能被1和自身整除的数
            for (int j = 2; j < i; j++) {
                //设置条件判断，若存在可以被整除的数(除1和自身)，修改flag为flase，只要存在一个就可以推翻。
                if(i % j == 0) {
                    flag = false;
                    break;  //此处加个break优化代码，只要找到一个，利用break结束当前循环的特性，直接结束内层循环。
                }
            }
            //内循环判断质数执行完毕，通过判断flag，打印输出质数，并统计个数
            if(flag) {
                //打印输出质数
                System.out.println(i + "是质数");
                //个数自增
                count++;
            }
        }
        //打印统计的个数
        System.out.println("质数的个数为:" + count);
    }
}

会打了上边的这个求质数的代码，来分析一个更深层次的问题。
打印1~100内的质数（只打印参数个质数就行，尽可能的优化代码）

/**
    利用continue，break简化质数的打印
    打印1~100之间的质数(要求打印参数个质数)
*/
class TestFor2 {

    public static void main(String[] args) {
        //从命令行获取参数
        int n = Integer.parseInt(args[0]);
        //设置计数器
        int count = 0;
        //循环遍历2~100(因为1不是质数)，并设置标签l1
        l1:for (int i = 2; i < 100; i++) {
            //设置循环判断i能否被除1和其本身之外的数整除，默认认为i是质数
            //因为利用continue加标签所以不用使用再进行最后的真假判断
            l2:for (int j = 2; j < i; j++) {
                //设置条件判断，若i不是质数，利用continue l1 结束当次循环，（这里的当次循环指的是标签处外循环）
                // 进入下一次循环(外层循环的迭代语句)
                if (i % j == 0) {
                    continue l1; 
                }
            }
            //内循环结束打印输出质数
            System.out.println(i + "是质数");
            //计数器自增1
            count++;
            //判断输出的质数是否符合题意，若符合利用break结束循环（结束的是break所属的循环即外层循环）
            if(count == n){
                break;
            }
        }
    }
}

如果能解决掉上述问题，对for循环的理解和使用非常熟练。
利用for循环还可以打印直角三角形，倒直角，99乘法表等等。如果会了上边的for循环，这些问题手到擒来。重点是灵活运用java中的基础知识，互相结合得到更多的东西。