for循环的经典程序分析

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

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

  1. /*
  2. 1. 输出从1到100之间所有的整数;(简单的单层for循环)**for循环遍历整数**
  3. 2. 输出从1到100之间所有的奇数;(通过与if-else结合,有条件的输出语句)
  4. 3. 输出从1到100之间所有不能被3整除的数;并输出这些整数的和;(通过增加条件,更合理的练习for循环与if语句结合)
  5. */
  6. public class NumberFor {
  7. public static void main (String[] args) {
  8. //这里利用输出语句打印一个提示语句
  9. System.out.println("输出从1到100之间所有的整数;");
  10. //输出从1到100之间所有的整数;
  11. for (int i = 1; i < 100; i++) {
  12. /*
  13. i 为循环因子,根据题意i要初始化为1,i < 100,每个整数都要打印,因此迭代语句自增为1.
  14. 程序执行1~100(没有100)共99次 次数:计算方法(100-1)
  15. */
  16. //循环体
  17. System.out.print(i + " ");
  18. }
  19. System.out.println("\n" + "输出从1到100之间所有的奇数;");
  20. //输出从1到100之间所有的奇数
  21. for (int i = 1; i < 100; i++) {
  22. //设置条件判断,有条件的输出循环
  23. if (i % 2 != 0) {
  24. System.out.print(i + " ");
  25. }
  26. }
  27. System.out.println("\n" + "输出从1到100之间所有不能被3整除的数;并输出这些整数的和");
  28. //输出从1到100之间所有不能被3整除的数;并输出这些整数的和
  29. //最后要输出整数的和,要提前声明一个保存和的变量
  30. int sum = 0;
  31. for (int i = 1; i < 100; i++) {
  32. if (i % 3 != 0) {
  33. //每次循环都进行判断,若真执行{}中语句
  34. System.out.print(i + " ");
  35. //将符合条件的i进行累加
  36. sum += i;
  37. }
  38. }
  39. System.out.println("\n" + "这些数的和为:" + sum);
  40. }
  41. }

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

  1. *****
  2. *****
  3. ***** 每一行5个星星,共有3

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

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

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

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

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

  1. class LoopTest3{
  2. public static void main(String[] args) {
  3. //从命令行获取n,m
  4. int n = Integer.parseInt(args[0]);
  5. int m = Integer.parseInt(args[1]);
  6. //外循环控制行数
  7. for (int i = 0; i < n; i++) {
  8. //外循环控制列数
  9. for (int j = 0; j < m; j++) {
  10. System.out.print("*");
  11. }
  12. //内层循环执行完后,进行换行
  13. System.out.println();
  14. }
  15. }
  16. }

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

  1. /**
  2. 打印n*m的空心矩形
  3. */
  4. public class TestFor {
  5. public static void main(String[] args) {
  6. //从命令行获取n,m
  7. int n = Integer.parseInt(args[0]);
  8. int m = Integer.parseInt(args[1]);
  9. for (int i = 0; i < n; i++) {
  10. //将首尾行与其他行分开打印
  11. if (i == 0 || i == n-1) {
  12. //打印首尾行
  13. for (int j = 0; j < m; j++){
  14. System.out.print("*");
  15. }
  16. }else {
  17. //打印其他行
  18. for (int j = 0; j < m; j++) {
  19. //其他行,控制首列和尾列的打印
  20. if(j == 0 || j == m-1) {
  21. System.out.print("*");
  22. }else {
  23. System.out.print(" ");
  24. }
  25. }
  26. }
  27. System.out.println();
  28. }
  29. }
  30. }

3.嵌套循环深入

  1. /*
  2. 分析过程:
  3. 打印等腰三角形(高度为5)
  4. 底边长度为9 1 3 5 7 9
  5. 空格数 i *
  6. 4 0 * 1
  7. 3 1 *** 3
  8. 2 2 ***** 5
  9. 1 3 ******* 7
  10. 0 4********* 9
  11. * = 2i + 1 *与行数成正比 y=kx+b
  12. 空格 = 4-i = 5-1-i 空格与行数成反比
  13. */
  14. public class TestFor {
  15. public static void main(String[] args) {
  16. for(int i = 0; i < 5; i++) {
  17. //从0行开始
  18. //程序顺序执行,先打空格,空格与行数的关系 5-1-i//5-(i+1)
  19. //这里j因为不在同一个{}中,所以都可以用j
  20. for(int j = 0; j < (5 - 1) - i; j++) {
  21. System.out.print(" ");
  22. }
  23. //星星打印数1 3 5 7 9 与行数关系(2*行数)+1
  24. for (int j = 0; j < (2 * i) + 1; j++) {
  25. System.out.print("*");
  26. }
  27. //换行
  28. System.out.println();
  29. }
  30. }
  31. }
  32. /*
  33. 拓展一下,打印高度为n的等腰三角形
  34. 实际只需要将外层循环5换成n就好
  35. */
  36. class TestFor1 {
  37. public static void main(String[] args) {
  38. //从命令行获取参数
  39. int n = Integer.parseInt(args[0]);
  40. //设置外循环控制行数
  41. for (int i = 0; i < n; i++) {
  42. //设置内循环控制列中空格的打印
  43. for (int j = 0; j < n - 1 - i; j++) {
  44. System.out.print(" ");
  45. }
  46. //设置并列内循环控制列中*的打印
  47. for (int j = 0; j < (2 * i) + 1; j++) {
  48. System.out.print("*");
  49. }
  50. //换行
  51. System.out.println();
  52. }
  53. }
  54. }

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

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

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

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

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

  1. /*
  2. 打印100-200之间的所有质数,并统计个数
  3. 这个题,共有两个问题。
  4. 1.打印100~200所有质数
  5. 2.统计质数的个数
  6. 思路:利用反证法
  7. 质数的个数统计应该和质数输出在同一个{}中
  8. */
  9. class TestFor1 {
  10. public static void main(String[] args) {
  11. //设置计数器,用于统计质数的个数
  12. int count = 0;
  13. //利用for循环遍历100~200所有整数,不包括200.
  14. for (int i = 100; i < 200; i++) {
  15. //先假设i为质数,利用反证法 设置一个布尔变量,值为true时为质数,值为false时,不是质数
  16. boolean flag = true;
  17. //设置内循环对每个数进行判断
  18. //质数:只能被1和自身整除的数
  19. for (int j = 2; j < i; j++) {
  20. //设置条件判断,若存在可以被整除的数(除1和自身),修改flag为flase,只要存在一个就可以推翻。
  21. if(i % j == 0) {
  22. flag = false;
  23. break; //此处加个break优化代码,只要找到一个,利用break结束当前循环的特性,直接结束内层循环。
  24. }
  25. }
  26. //内循环判断质数执行完毕,通过判断flag,打印输出质数,并统计个数
  27. if(flag) {
  28. //打印输出质数
  29. System.out.println(i + "是质数");
  30. //个数自增
  31. count++;
  32. }
  33. }
  34. //打印统计的个数
  35. System.out.println("质数的个数为:" + count);
  36. }
  37. }

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

  1. /**
  2. 利用continue,break简化质数的打印
  3. 打印1~100之间的质数(要求打印参数个质数)
  4. */
  5. class TestFor2 {
  6. public static void main(String[] args) {
  7. //从命令行获取参数
  8. int n = Integer.parseInt(args[0]);
  9. //设置计数器
  10. int count = 0;
  11. //循环遍历2~100(因为1不是质数),并设置标签l1
  12. l1:for (int i = 2; i < 100; i++) {
  13. //设置循环判断i能否被除1和其本身之外的数整除,默认认为i是质数
  14. //因为利用continue加标签所以不用使用再进行最后的真假判断
  15. l2:for (int j = 2; j < i; j++) {
  16. //设置条件判断,若i不是质数,利用continue l1 结束当次循环,(这里的当次循环指的是标签处外循环)
  17. // 进入下一次循环(外层循环的迭代语句)
  18. if (i % j == 0) {
  19. continue l1;
  20. }
  21. }
  22. //内循环结束打印输出质数
  23. System.out.println(i + "是质数");
  24. //计数器自增1
  25. count++;
  26. //判断输出的质数是否符合题意,若符合利用break结束循环(结束的是break所属的循环即外层循环)
  27. if(count == n){
  28. break;
  29. }
  30. }
  31. }
  32. }

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

发表评论

表情:
评论列表 (有 0 条评论,280人围观)

还没有评论,来说两句吧...

相关阅读

    相关 for循环经典程序分析

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