Robin1985

导航

 
JavaSE学习笔记 05 循环

Java提供了一种被称为循环（loop）的功能强大的结构，用来控制一个操作或操作序列重复执行的次数。循环是用来控制语句块重复执行的一种结构。循环的概念是程序设计的基础，Java提供了三种类型的循环语句：while循环、do-while循环和for循环。

while循环

​ while循环的语法如下：

​ while (循环继续条件) {

​ 　//循环体

​ 　语句;

​ }

​ 循环中包含的重复执行的语句部分称为循环体（loop body）。只要循环继续条件为 true，循环体会一直执行下去。

​ 编写循环时应该考虑如下三个步骤：

  1. 确定需要重复的语句。

  2. 将这些语句放在一个循环体中。

  3. 为循环继续条件编码，并未控制循环添加合适的语句。

    while (循环继续条件) {

    ​ 　语句组;

    ​ 　用于控制循环的附件语句;

    }

do-while循环

​ do-while循环是while循环的变体，它的语法如下：

​ do {

​ 　//循环体;

​ 　语句;

​ } while (循环继续条件);

​ do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

for循环

​ for循环执行的次数是在执行前就确定的。语法格式如下：

​ for (初始操作;循环继续条件;更新迭代后的操作) {

​ 　//循环体;

​ 　语句;

​ }

​ for循环执行步骤：

  • 最先执行初始化操作。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。

  • 然后，检测循环继续条件的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。

  • 执行一次循环后，更新迭代后的操作。

  • 再次检测循环继续条件。

采用哪种循环

​ 建议使用自己觉得最自然、最舒服的一种循环语句。如果已经提前知道重复次数，那就采用for循环。如果无法确定重复次数，就采用while循环。如果在检测继续条件前需要执行循环体，就用do-while循环替代while循环。

嵌套循环

​ 嵌套循环是由一个外层循环和一个或多个内层循环组成的。每当重复执行一次外层循环时再次进入内部循环，然后重新开始。

break和continue

​ break主要用在循环语句或者switch语句中，用来跳出整个语句块。break跳出最里层的循环，并且继续执行该循环下面的语句。

​ continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在for循环中，continue语句使程序立即跳转到更新迭代后的操作。在while或do-while循环中，程序立即跳转到循环继续条件进行判断。

编程练习

问题1：求两整数最大公约数

​ 公约数是一个能被若干个整数同时均整除的整数。

​ 思路：假设输入的两个整数n1和n2。已知1是一个公约数，但它不是最大的公约数。所以，可以通过循环不断累加来计算能够同时被n1和n2整除的数，直到累加到能被同时整除的数即可。

 1 import java.util.Scanner;
 2 /**
 3  * 获取任意两个整数的最大公约数
 4  */
 5 public class MaxDivisor {
 6     public static void main(String[] args) {
 7         Scanner input = new Scanner(System.in);
 8         System.out.println("请输入第一个整数：");
 9         //第一个整数
10         int num1 = input.nextInt();
11         System.out.println("请输入第二个整数：");
12         //第二个整数
13         int num2 = input.nextInt();
14         //最大公约数变量
15         int max = 1;
16         //迭代变量
17         int k = 2;
18         while (k <= num1 && k <= num2) {
19             if ((num1 % k == 0) && (num2 % k == 0)) {
20                 max = k;
21             }
22             k++;
23         }
24         System.out.println(num1 + "与" + num2 + "的最大公约数为：" + max);
25     }
26 }

问题2：打印左侧直角三角形

​ 编写程序，提示用户输入一个1到9之间的整数，然后显示该整数左侧三角形的图案，图案如下所示：

​ 1​

 12​

 123​

 1234​

 12345

​ 思路：通过图形分析，可以使用循环嵌套，外层循环控制行数，内层循环控制符号个数。每一行内层循环打印符号的个数，刚好是外层循环的行数。

 1 import java.util.Scanner;
 2 /**
 3  * 打印左直角三角形
 4  */
 5 public class PrintLeftNum {
 6     public static void main(String[] args) {
 7         Scanner input = new Scanner(System.in);
 8         System.out.println("请输入1-9之间的整数：");
 9         int num = input.nextInt();
10         //控制行数
11         for (int i = 1; i <= num; i++) {
12             //控制打印数字
13             for (int j = 1; j <= i; j++) {
14                 System.out.print(j);
15             }
16             //换行
17             System.out.println();
18         }
19     }
20 }

问题3：打印左侧直角倒三角形

​ 如题2，但图案相反，如下所示：​

 12345​

 1234​

 123​

 12​

 1

​ 思路：通过图形与题2分析，使用嵌套循环，外层循环控制行数，内层循环控制符号个数。但内层循环符号的个数，应该是外层每一行减去上一行所打印的个数。

 1 import java.util.Scanner;
 2 /**
 3  * 打印左直角倒三角形
 4  */
 5 public class PrinLeftBackNum {
 6     public static void main(String[] args) {
 7         Scanner input = new Scanner(System.in);
 8         System.out.println("请输入1-9之间的整数：");
 9         int num = input.nextInt();
10         //控制行数
11         for (int i = 0; i <= num; i++) {
12             //打印数字
13             for (int j = 1; j <= num - i; j++) {
14                 System.out.print(j);
15             }
16             //换行
17             System.out.println();
18         }
19     }
20 }

问题4：打印右侧直角三角形

​ 如题2，但图案相反，显示该整数右侧三角形的图案，图案如下所示：

​ 　　  1​

　　 12​

     123​

   1234​

 12345

​ 思路：通过图形与题2题3分析得出，实际是两者的结合。只需将提3的数字变成空格即可。

 1 import java.util.Scanner;
 2 /**
 3  * 打印右直角三角形
 4  */
 5 public class PrintRightNum {
 6     public static void main(String[] args) {
 7         Scanner input = new Scanner(System.in);
 8         System.out.println("请输入1-9之间的整数：");
 9         int num = input.nextInt();
10         //控制行数
11         for (int i = 1; i <= num; i++) {
12             //打印空格
13             for (int j = 1; j <= num - i; j++) {
14                 System.out.print(" ");
15             }
16             //控制打印数字
17             for (int j = 1; j <= i; j++) {
18                 System.out.print(j);
19             }
20             //换行
21             System.out.println();
22         }
23     }
24 }

问题5：打印等腰三角形

​ 编写程序，提示用户输入一个在1到9之间的整数，然后显示一个等腰三角形的图案，图案如下所示：

​         1​

       121​

     12321​

   1234321​

 123454321

​ 思路：通过图形与题2题3题4分析得出，图形右侧为每行输出数字的倒叙打印同时右侧的输出应比左侧低一行。

 1 import java.util.Scanner;
 2 /**
 3  * 打印等腰三角形
 4  *     1            i = 1   0
 5  *    12  1         i = 2   1
 6  *   123  21        i = 3   2
 7  *  1234  321       i = 4   3
 8  * 12345  4321        i = 5   4    
 9  */
10 public class PrintIsosceles {
11     public static void main(String[] args) {
12         Scanner input = new Scanner(System.in);
13         System.out.println("请输入1-9之间的整数：");
14         int num = input.nextInt();
15         //控制行数
16         for (int i = 1; i <= num; i++) {
17             //打印空格
18             for (int j = 1; j <= num - i; j++) {
19                 System.out.print(" ");
20             }
21             //控制打印左侧数字
22             for (int j = 1; j <= i; j++) {
23                 System.out.print(j);
24             }
25             //控制打印右侧数字，第一行不打印，降低一行，第二行开始从大到小打印
26             for (int j = i - 1; j >= 1; j--) {
27                 System.out.print(j);
28             }
29             //换行
30             System.out.println();
31         }
32     }
33 }

问题6：显示闰年

​ 编写程序，显示21世纪（2001年~2100年）中所有的闰年，每行显示10个。

​ 思路：通过循环遍历2001-2100年份，判断闰年，若成立则显示，同时通过计数器来计算闰年数量。

 1 /**
 2  * 计算2001年-2100年间闰年数量。
 3  */
 4 public class LeapYears {
 5     public static void main(String[] args) {
 6         //计数君，当到10时，换行，初始为0
 7         int count = 0;
 8         for (int i = 2001; i <= 2100; i++) {
 9             if ((i % 4 ==0 && i % 100 != 0) || (i % 400 == 0)) {
10                 count++;
11                 System.out.print(i + " ");
12                 if (count % 10 == 0) {
13                     count = 0;
14                     System.out.println();
15                 }
16             }
17         }
18     }
19 }

问题7：万年历

​ 编写程序，提示用户输入年份及月份，然后在控制台上，显示该年该月的日历表。示例如下所示：

​ --------------------欢迎使用Java万年历--------------------

​ 请输入要查看的年份:2017

​ 请输入要查看的月份：3

​ -------------------------------------------------------------

​ 星期日 星期一 星期二 星期三 星期四 星期五 星期六

​ 　　　　　　　　　　1 　　 2        3        4

​ 5 　　 6 　　 7 　　 8 　　 9 　　 10 　  11

​ 12 　  13 　  14      15 　  16 　  17 　  18

​ 19 　  20 　  21 　  22 　  23 　  24      25

​ 26 　  27 　  28 　  29 　  30      31

​ 思路：通过查看日历，分析得出日历的主要规律为以下几点：

  • 根据常识，知道年份有平年、闰年之分，要根据规则判断出平年还是闰年。

  • 根据平年或闰年来划分2月的天数，平年28天，闰年29天。

  • 无论平年还是闰年，除了2月，1、3、5、7、8、10、12这几个月为31天，4、6、9、11这几个月为30天。

  • 该月第一天是星期几是最难最关键的，并且为了日历好看，根据星期几前要加对应空格。

    • 日期是连续的，比如当月31日为周一，下月不管是几月，下月的1号都为周二。

    • 为了便于计算，翻看日历查到1900年1月1日为星期一。

    • 无论多少年多少月，一周总共为7天。这样将总天数对7取模，结果就为对应的星期。例如：1为周一，2为周二以此类推。注意：结果为0时，为周日。

  1 import java.util.Scanner;
  2 /**
  3  * 1900年1月1日开始的万年历。
  4  */
  5 public class Calendar {
  6     public static void main(String[] args) {
  7         // 定义要输入的年份，默认为0
  8         int year = 0;
  9         // 定义要输入的月份，默认为0
 10         int month = 0;
 11         // 定义根据输入的年份，月份要显示的日期数，默认为0
 12         int days = 0;
 13         // 定义判断是否为闰年还是平年的flag，默认为false
 14         boolean isLeapYear = false;
 15         // 定义根据输入的年份，到1900年1月1日范围的年的总天数，默认为0
 16         int totalYearDays = 0;
 17         // 定义根据输入的月份，到输入年份范围的月的总天数，默认为0
 18         int totalMonthDays = 0;
 19         // 定义根据输入的年份，月份（不算输入的月份）到1900年1月1日范围的总天数，默认为0
 20         int totalDays = 0;
 21         // 定义输入的月份的第一天是星期几，默认为0
 22         int weekDay = 0;
 23         Scanner input = new Scanner(System.in);
 24         System.out.println("------------------------欢迎使用Java万年历------------------------");
 25         System.out.println("请输入要查询的年份：");
 26         year = input.nextInt();
 27         System.out.println("请输入要查询的月份：");
 28         month = input.nextInt();
 29 
 30         // 1.判断输入的年份是闰年还是平年
 31         isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) ? true : false;
 32         System.out.println("当前输入的年份为：" + (isLeapYear ? "闰年" : "平年"));
 33         // 2.计算从1900年到输入年份，只是年之间的总天数，但是不能计算输入的年份，因为输入的月份不确定
 34         for (int i = 1900; i < year; i++) {
 35             if ((i % 4 == 0 && i % 100 != 0) || (i % 400 == 0)) { // 闰年
 36                 totalYearDays += 366;
 37             } else { // 平年
 38                 totalYearDays += 365;
 39             }
 40         }
 41         System.out.println("从1900年到" + year + "年之间（不算 +" + year + "年）所有的总天数：" + totalYearDays);
 42         // 3.根据输入月份，计算从1月到该月（不算该月）的总天数
 43         for (int i = 1; i <= month; i++) { //i <= month 要获取输入月份的天数
 44             switch (i) {
 45             case 1:
 46             case 3:
 47             case 5:
 48             case 7:
 49             case 8:
 50             case 10:
 51             case 12:
 52                 days = 31;
 53                 break;
 54             case 4:
 55             case 6:
 56             case 9:
 57             case 11:
 58                 days = 30;
 59                 break;
 60             case 2:
 61                 if (isLeapYear) {
 62                     days = 29;
 63                 } else {
 64                     days = 28;
 65                 }
 66             }
 67             //不算该月
 68             if (i < month) {
 69                 totalMonthDays += days;
 70             }
 71         }
 72         System.out.println("从" + year + "年1月1日开始到" + year + "年" + month + "月1日之前的总天数：" + totalMonthDays);
 73         // 4.计算输入的年份，月份（不算输入的月份）到1900年1月1日范围的总天数
 74         totalDays = totalMonthDays + totalYearDays;
 75         System.out.println("从1900年1月1日到" + year + "年" + month + "月之前的总天数：" + totalDays);
 76         // 5.根据输入月份计算第一天是星期几，因为没有计算输入的月份，所以，少加了一天。为了计算输入月份的第一天，所以需要加上
 77         weekDay = (totalDays + 1) % 7;
 78         switch (weekDay) {
 79         case 0:
 80             System.out.println(year + "年" + month + "月1日是星期日");
 81             break;
 82         case 1:
 83             System.out.println(year + "年" + month + "月1日是星期一");
 84             break;
 85         case 2:
 86             System.out.println(year + "年" + month + "月1日是星期二");
 87             break;
 88         case 3:
 89             System.out.println(year + "年" + month + "月1日是星期三");
 90             break;
 91         case 4:
 92             System.out.println(year + "年" + month + "月1日是星期四");
 93             break;
 94         case 5:
 95             System.out.println(year + "年" + month + "月1日是星期五");
 96             break;
 97         case 6:
 98             System.out.println(year + "年" + month + "月1日是星期六");
 99             break;
100         }
101         System.out.println("-----------------------------");
102         System.out.println("星期日\t星期一\t星期二\t星期三\t星期四\t星期五\t星期六");
103         // 6.根据计算出来的星期几，对输入月份第一天美化
104         for (int i = 0; i < weekDay; i++) {
105             System.out.print("\t");
106         }
107         // 7.输出输入月份的天数
108         for (int i = 1; i <= days; i++ ) {
109             System.out.print(i + "\t");
110             //当总天数累加对7取模，为6时即为星期六，换行
111             if (((totalDays + i) % 7) == 6 ) {
112                 System.out.println();
113             }
114         }
115     }
116 }

 

posted on 2017-03-19 13:08  Robin1985  阅读(141)  评论(0)    收藏  举报
 
博客园  ©  2004-2026
浙公网安备 33010602011771号 浙ICP备2021040463号-3