for循环的经典程序分析

短命女 2022-09-24 01:30 209阅读 0赞

**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中的基础知识，互相结合得到更多的东西。