JAVA语言语法_流程控制（part3）
文章目录
-
-
- JAVA语言语法
-
- 三、流程控制
-
- 1、程序流程控制概述
- 2、顺序结构
- 3、分支结构
- 4、分支结构语句练习
- 5、加深键盘类Scanner类的使用
- 6、分支结构语句练习2
- 7、分支结构&switch分支
- 8、循环结构& for 循环（重点）
- 9、循环结构&for循环练习
- 10、循环结构&while循环
- 11、循环结构&do-while循环
- 12、循环结构&关键字break
- 13、循环结构&关键字continue
- 14、循环结构&关键字return
- 15、循环结构&嵌套循环（多重循环）
- 16、循环结构&嵌套循环练习1
- 17、循环结构&嵌套循环练习2
-
JAVA语言语法
三、流程控制
1、程序流程控制概述
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定给功能的小逻辑模块。
其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
（1）、顺序结构 : 程序从上到下逐行地执行，中间没有任何判断和跳转。
（2）、分支结构 :
根据条件，选择性地执行某段代码
有if、if-else、if-else if..else和switch-case的两种分支语句。
（3）、循环结构
根据循环条件，重复性地执行某段代码;
有while、do-while、for三种循环语句;
注意: JDK1.5开始提供了foreach的循环, 方便遍历集合、数组元素。
2、顺序结构
3、分支结构
（1）、分支语句 if
（2）、分支语句 if-else
（3）、分支语句 if else if …else
if -else 使用说明：
(1)、条件表达式必须是布尔表达式(关系表达式或者逻辑表达式)、布尔变量;
(2)、语句块只有一条执行语句时，一队花括号{}可以省略，但是建议保留;
(3)、if-else语句结构，根据需要可以嵌套使用;
(4)、当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略;
(5)、当多个条件是“互斥”关系时，条件判断语句以及执行语句间顺序是无所谓的; 当多个条件是“包含”关系时，可遵循“小上大下/子上父下” （即是范围小的声明在范围大的上面）。
4、分支结构语句练习
代码演示：
package com.rucoding.d5;
/**
* @author LiuYiXin
*
*/
public class IfelseDemo01 {
public static void main(String[] args) {
/*
* 第一种:
* if(条件表达式){
* 执行表达式
* }
*
* 第二种:
* if(条件表达式){
* 执行表达式1
* }else{
* 执行表达式2
* }
*
* 第三种:
* if(条件表达式1){
* 执行表达式1
* }else if(条件表达式2){
* 执行表达式2
* }else if(条件表达式3){
* 执行表达式3
* }
* ...
* else{
* 执行表达式n
* }
*
*/
//举例1 if语句
int heartBeats = 179;
if(heartBeats < 60 || heartBeats > 100){
System.out.println("需要进一步做检查");
}
System.out.println("检查结束");
//举例2 if-else语句
int age = 23;
if(age < 18){
System.out.println("你还未成年呢");
}else{
System.out.println("你是成年人了");
}
//举例3 if else-if ...else 语句
if(age < 0){
System.out.println("数据有误");
}else if(age < 18){
System.out.println("你还是青少年呢");
}else if(age < 35){
System.out.println("你是青壮年呢");
}else if(age < 60){
System.out.println("你是中年人了");
}else if(age < 120){
System.out.println("你已进入老年人生活啦");
}else{ //根据实际的场景，这里的else是可以去除的。
System.out.println("你比乌龟还牛。。。");
}
}
}
5、加深键盘类Scanner类的使用
场景模拟：假如需要获取键盘的输入，此时需要从键盘获取不同类型的数据类型，需要使用到Scanner类。
具体步骤:
1.查看API文档;
2.需要导入包: import java.util.Scanner;
3.Scanner的实例化;
4.调用Scanner类的相关方法, 来获取指定的变量。
代码演示：
这里有个疑问：每次运行输出sout语句，光标不能直接换行的哟。能解不？
package com.rucoding.d5;
import java.util.Scanner;
/**
* @author LiuYiXin
*
*/
public class ScannerDemo01 {
public static void main(String[] args) {
//声明一个Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的幸运数字: ");
int i = scanner.nextInt();//nextInt()方法接收的是数字类型
System.out.println("你输入的幸运数字为：" + i);
//录入大一新生的基本信息
System.out.println("请输入你的姓名：");
String stuName = scanner.next();
System.out.println("你输入的姓名为：" + stuName);
System.out.println("请输入你的年龄：");
int stuAge = scanner.nextInt();
System.out.println("你输入的年龄为：" + stuAge);
System.out.println("请输入你的体重：");
double stuWeight = scanner.nextDouble();
System.out.println("你输入的体重为：" + stuWeight);
System.out.println("请选择你单身与否？（true(是)/false(否)）");
boolean stuIsSingle = scanner.nextBoolean();
System.out.println("你选择的是：" +stuIsSingle);
//char类型的获取, Scanner类没有提供相应的方法, 只能获取一个字符串
System.out.println("请输入你的性别：（男/女）");
String stuSex = scanner.next();
char stuGender = stuSex.charAt(0);
System.out.println("你输入的性别属性为：" + stuGender);
}
}
6、分支结构语句练习2
代码演示1：
package com.rucoding.d5;
import java.util.Scanner;
/**
* @author LiuYiXin
*
*/
public class IfelseDemo02 {
public static void main(String[] args) {
//分支结构语句if else-if else的练习
/*
岳小鹏参加数学考试，他和父亲岳不群达成承诺：
如果：成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断
*/
//声明Scanner类
Scanner scanner = new Scanner(System.in); //接收键盘的输入System.in
System.out.println("请输入岳小鹏的数学成绩：");
int stuScore = scanner.nextInt();
if(stuScore == 100){
System.out.println("岳小鹏的数学成绩为：" + stuScore + ",奖励一辆BMW");
}else if(stuScore > 80 && stuScore <= 99){
System.out.println("岳小鹏的数学成绩为：" + stuScore + ",奖励一台iphone xs max");
}else if(stuScore >= 60 && stuScore <= 80){
System.out.println("岳小鹏的数学成绩为：" + stuScore + ",奖励一个iPad");
}else if(stuScore < 0 || stuScore > 100){
System.out.println("输入的数字有误,请检查！");
}else{
System.out.println("不及格, 什么奖励也没有");
}
}
}
7、分支结构&switch分支
switch - case 结构：
注意：
switch-case 结构中的表达式, 只能是如下的六种数据类型之一: byte、short、char、int、枚举类型(JDK5.0)、String类型(JDK7.0)
不能是: boolean、long、float、double类型。
温馨Tip：以下练习题目，可自由安排时间，比如是每日一题，练练手。
练习1代码演示：
package com.rucoding.d5;
/**
* @author LiuYiXin
*
*/
public class SwitchCaseDemo01 {
public static void main(String[] args) {
//分支结构之二: switch-case结构
/*
* 格式定义：
* switch(表达式){
* case 常量1:
* 执行语句1;
* //break;
* case 常量2:
* 执行语句2;
* //break;
* ...
* default:
* 执行语句n;
* break;
* }
*/
//说明:
//①.根据switch表达式的值, 依次匹配各个case的值,一旦匹配成功,则进入对应的case语句,执行相关语句。
//②.当调用完执行的语句后,则仍然继续向下执行其他的case语句,直到遇见break关键字或末尾结束为止。
//③.break关键字，可以使用在switch-case语句中，表示一旦执行遇到该关键字，就会跳出switch-case结构。
//④.switch-case 结构中的表达式, 只能是如下的六种数据类型之一: byte、short、char、int、枚举类型(JDK5.0)、String类型(JDK7.0)! 不能是: boolean、long、float、double类型
//⑤.case之后声明的是常量，不能声明范围。
//⑥.break关键字是可选的。
//⑦.default：相当于if-else的else default结构是可选的，而且位置是灵活的。
//switch-case可以接受的表达式 int类型
int num = 2;
switch(num){
case 0:
System.out.println("Zero");
case 1:
System.out.println("One");
case 2:
System.out.println("Two");
break;//此处如果不加break,那么遇到case 2执行的时候,会继续执行其他case语句,直到遇见break或者末尾字节结束才会跳出
case 3:
System.out.println("Three");
break;
case 4:
System.out.println("Four");
break;
case 5:
System.out.println("Five");
break;
default:
System.out.println("Other...");
break;
}
//switch-case不能接收的表达式类型，比如boolean类型。
boolean isOk = true;
switch(isOk){ //无法接收boolean类型的表达式 ,无法通过编译。
case true:
System.out.println("Ok");
break;
case false:
System.out.println("Not Ok");
break;
default:
System.out.println("信息有误！");
break;
}
//String类型的，自从jdk1.7开始
String season = "spring";
switch(season){
case "spring":
System.out.println("春暖花开");
break;
case "summer":
System.out.println("夏日炎炎");
break;
case "autumn":
System.out.println("秋高气爽");
break;
case "winter":
System.out.println("白雪皑皑");
break;
default:
System.out.println("输入有误！");
break;
}
}
}
练习2代码演示：
package com.rucoding.d5;
import java.util.Scanner;
/**
* @author LiuYiXin
*
*/
public class SwitchCaseDemo02 {
public static void main(String[] args) {
/*
使用switch 把小写类型的char型转为大写。只转换a, b, c, d, e. 其它的输出“other”。
提示：String word = scan.next(); char c = word.charAt(0); switch(c){}
*/
//声明Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("输入小写的字母,会自动转为大写：");
String str = scanner.next();
char lowerWord = str.charAt(0);//获取指定索引位置的值
//
switch(lowerWord){
case 'a':
System.out.println("A");
break;
case 'b':
System.out.println("B");
break;
case 'c':
System.out.println("C");
break;
case 'd':
System.out.println("D");
break;
case 'e':
System.out.println("E");
break;
default:
System.out.println("other...");
break;
}
}
}
练习3代码演示：
package com.rucoding.d5;
/**
* @author LiuYiXin
*
*/
public class SwitchCaseDemo03 {
public static void main(String[] args) {
/*
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
说明：如果switch-case语句中多个相同语句，可以进行合并。
*/
int stuScore = 78;
switch(stuScore / 10){
case 0: //switch-case语句中执行多个相同的语句，可以进行合并操作
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("不合格");
break;
case 6:
case 7:
case 8:
case 9:
case 10:
System.out.println("合格");
break;
default:
System.out.println("输入有误");
break;
}
//优化上述,更优解
switch(stuScore / 60){
case 0:
System.out.println("不合格");
break;
case 1:
System.out.println("合格");
break;
default:
System.out.println("输入有误！");
break;
}
}
}
练习4代码演示：
*/
//利用分支结构switch-case实现
int month = 10;
switch(month){
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("输入月份有误");
break;
}
练习5代码演示：
package com.rucoding.d6;
import java.util.Scanner;
/**
* @author LiuYiXin
*
*/
public class SwitchCaseDemo01 {
public static void main(String[] args) {
/*
编写程序：从键盘上输入2019年的"month"和"day",
要求通过程序输出 输入的日期为2019年的第几天。
比如2 月 15 日 : 31 + 15 即是1月31天 + 15
5 7: 31 + 28 +31 +30 + 7
...
说明：break在switch-case中是可选的。
*/
//声明从键盘接收的Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("请输入合法月份month: ");
int month = scanner.nextInt();
System.out.println("请输入合法日期day: ");
int day = scanner.nextInt();
//定义总变量天数
int sumDays = 0;
switch(month){
// case 1:
// sumDays = day;
// break;
// case 2:
// sumDays = 31 + day;
// break;
// case 3:
// sumDays = 31 + 28 + day;
// case 4:
// sumDays = 31 + 28 + 31 + day;写着写着发现太冗余了,很多都是重复的代码 31 + .. day 一直都在，优化一下
//我们倒着写
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
sumDays += 28;
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println("2019年的" + month + "月" + day + "日是第2019年" + sumDays + "天");
}
}
练习5代码演示（升级版）：
package com.rucoding.d6;
import java.util.Scanner;
/**
* @author LiuYiXin
*
*/
public class SwitchCaseDemo02 {
public static void main(String[] args) {
/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4 整除，但是不能被100整除; 【判断方法一】
2）可以被400整除。 【或者直接能被400整除 判断方法二】
翻译成计算机能听懂的语言：
((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
说明:
1凡是可以使用switch-case的结构,都可以转换为if-else。反之,不成立。
2.我们写分支结构时,当发现既可以使用switch-case,
(同时,switch中表达式的取值情况不太多),
又可以使用，我们优先选择使用switch-case。原因:switch-case执行效率稍高。
*/
//这题是上面练习4的升级， 多了一个年份， 改变了 2月的天数，闰年的2月是29天，平年的2月是28天
//声明一个接收键盘输入的Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("请输入合法的年份Year：");
int year = scanner.nextInt();
System.out.println("请输入合法的年份Month：");
int month = scanner.nextInt();
System.out.println("请输入合法的年份Day：");
int day = scanner.nextInt();
//定义变量 ，总天数
int sumDays = 0;
switch(month){
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
//判断输入的year年份是否为闰年
if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)){
sumDays += 29;
}else{
sumDays += 28;
}
case 2:
sumDays +=31;
case 1:
sumDays += day;
}
System.out.println(year + "年的" + month + "月" + day + "日是第" + year + "年" + sumDays + "天");
}
}
练习6代码演示：
package com.rucoding.d6;
import java.util.Scanner;
/**
* @author LiuYiXin
*
*/
public class SwitchCaseDemo03 {
public static void main(String[] args) {
/*
编写一个程序，为一个给定的年份找出其对应的中国生肖。
中国的生肖基于12年一个周期，每年用一个动物代表：
十二生肖速算法：出生的年份除以12 ，取余数，如果能整除，余数视为0
按照下列余数数字对应生肖动物
0-猴 1-鸡 2-狗 3-猪 4-鼠 5-牛 6-虎 7-兔 8-龙 9-蛇 10-马 11-羊
比如：2019年： 2019 % 12 == 3（余数） ，即是生肖为 猪
*/
//声明一个键盘接收Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的诞生年份year: ");
int year = scanner.nextInt();
//除以12,取余变量
int num = year % 12;
switch(num){
case 0:
System.out.println("你的生肖为猴");
break;
case 1:
System.out.println("你的生肖为鸡");
break;
case 2:
System.out.println("你的生肖为狗");
break;
case 3:
System.out.println("你的生肖为猪");
break;
case 4:
System.out.println("你的生肖为鼠");
break;
case 5:
System.out.println("你的生肖为牛");
break;
case 6:
System.out.println("你的生肖为虎");
break;
case 7:
System.out.println("你的生肖为兔");
break;
case 8:
System.out.println("你的生肖为龙");
break;
case 9:
System.out.println("你的生肖为蛇");
break;
case 10:
System.out.println("你的生肖为马");
break;
case 11:
System.out.println("你的生肖为羊");
break;
default:
System.out.println("输入信息有误！");
break;
}
}
}
8、循环结构& for 循环（重点）
循环结构描述： 在某些条件满足的条件下，反复执行特定代码的功能。
循环结构的分类：
（1）、for循环
（2）、while循环
（3）、do-while循环
举例图解：
9、循环结构&for循环练习
温馨Tip：以下练习题目，可自由安排时间，比如是每日一题，练练手。
练习1代码演示：
package com.rucoding.d5;
/**
* @author LiuYiXin
*
*/
public class ForDemo01 {
public static void main(String[] args) {
//for循环
/*
* for的语法格式
* for(①初始化部分;②循环条件部分;④迭代部分){
* ③.循环体部分;
* }
*
* 执行过程: ①-②-③-④-②-③-④-②-③-④...
*/
//for循环结构的使用：基本要素：①.初始化条件;②.循环条件;③.循环体部分;④.迭代条件部分。
/*结构
* for(①;②;④){
* ③
* }
*/
for(int i=1;i <= 5;i++){
System.out.println("HelloWorld");
}
//练习
int num = 1;
for(System.out.print('a');num <= 3;System.out.print('c'),num++){
System.out.print('b'); //输出结果 abcbcbc
}
System.out.println();
//练习2
//遍历100以内的偶数,获取所有偶数的和,输出偶数的个数
int sum = 0;
int count = 0;
for(int i=1;i <= 100;i++){
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
}
System.out.println("偶数总数和: " + sum + ",偶数个数：" + count);
}
}
练习2代码演示：
package com.rucoding.d5;
/**
* @author LiuYiXin
*
*/
public class ForDemo02 {
/*
编写程序从1循环到150，并在每行打印一个值，
另外在每个3的倍数行上打印出“foo”,
在每个5的倍数行上打印“biz”,
在每个7的倍数行上打印输出“baz”。
*/
public static void main(String[] args) {
for(int i=1;i <= 150;i++){
System.out.print(i + " ");
if(i % 3 == 0){
System.out.print("foo" + " "); //不换行
}
if(i % 5 == 0){
System.out.print("biz" + " ");
}
if(i % 7 == 0){
System.out.print("baz");
}
System.out.println(); //遍历完一个数，打印换行操作
}
}
}
练习3代码演示：
package com.rucoding.d6;
import java.util.Scanner;
/**
* @author LiuYiXin
*
*/
public class ForDemo01 {
public static void main(String[] args) {
/*
输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用
*/
// 分析一下：
//12的约数，1 、2、3、4、6、12 (约束就是能被整除的)
//20的约数，1、2、4、5、10、20
//此时最大的公约数肯定不会超过 最小数那个，即12
//声明一个键盘的接收类Scanner
Scanner scanner = new Scanner(System.in);
System.out.println("请输入合法的正整数m: ");
int m = scanner.nextInt();
System.out.println("请输入合法的正整数n: ");
int n = scanner.nextInt();
//求最大公约数
//判断两个数的最小值
int min = (m < n) ? m : n; //循环条件部分
for(int i=min;i >=1;i--){ //最大不会超过最小那个12，从12开始递减取最大的
if(m % i == 0 && n % i == 0){
System.out.println(m + "和" + n + "的最大公约数为：" + i);
break;
}
}
//求两个数的最小公倍数
//分析一下：
//12和20 的公倍数，范围最大在他们俩的乘积 m*n 即是 12*20 = 240，最小的范围大于最大那个值
//判断两个数的最大值
int max = (m > n) ? m : n;
for(int i=max;i <= m*n;i++){ //循环条件部分
if(i % m == 0 && i % n == 0){
System.out.println("最小的公倍数为：" + i);
break;
}
}
}
}
练习4代码演示：
package com.rucoding.d6;
/**
* @author LiuYiXin
*
*/
public class ForDemo02 {
/*
输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如：153 = 1*1*1 + 3*3*3 + 5*5*5
*/
public static void main(String[] args) {
//拆解，先取这个数个位、十位、百位
for(int i=100;i <=999;i++){
int ge = i % 10; //个位
int shi = i % 100 / 10; //十位
int bai = i / 100; //百位
// int result = ge^3 + shi^3 + bai^3; //a^3这样可不行， java中的^符号是来表示"异或" 运算的。
int result = ge*ge*ge + shi*shi*shi + bai*bai*bai;
if(i == result){
System.out.println("水仙花数是：" + i);
}
}
}
}
10、循环结构&while循环
基本语法格式：
①.初始化部分
while(②循环条件部分){
③.循环体部分;
④.迭代部分;
}
执行过程描述: ①-②-③-④-②-③-④-...②-③-④
说明：
(1)、注意不要忘记声明④迭代部分。否则,循环将不能结束，进入死循环。
(2)、for循环和while循环可以互相转换的。
代码演示：
package com.rucoding.d5;
/**
* @author LiuYiXin
*
*/
public class WhileDemo01 {
/*
* while循环结构的使用：
* 基本要素：
* ①.初始化条件
* ②.循环条件
* ③.循环体部分
* ④.迭代条件
*
* 结构：
* ①.初始化部分
* while(②.循环条件部分){
* ③.循环体部分;
* ④.迭代部分;
* }
*
* 执行过程描述: ①-②-③-④-②-③-④-...②-③-④
*
* 说明：
* 1、写while循环的，记得别丢了迭代条件，一旦丢失，可能会导致死循环
* 2、写程序避免死循环
* 3、while循环和for循环可以互相转换。
*
* 区别: for循环和while循环的初始化条件部分的作用范围不同。
*/
//遍历100以内的偶数,获取所有偶数的和,输出偶数的个数
public static void main(String[] args) {
//改用while循环实现
int sum =0;
int count =0;
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
i++;
}
System.out.println("偶数总和为：" + sum + ",偶数个数为：" + count);
}
}
11、循环结构&do-while循环
语法格式说明：
代码演示：
package com.rucoding.d5;
/**
* @author LiuYiXin
*
*/
public class DoWhileDemo01 {
/*
* do-while循环结构的使用
* 基本要素：
* ①.初始化条件
* ②.循环条件 ---> 是boolean类型
* ③.循环体
* ④.迭代条件
*
* 结构：
* ①.初始化条件
* do{
* ③.循环体部分
* ④.迭代部分
* }while(②.循环条件部分);
*
* 说明：do-while循环至少会执行一次循环体
*/
public static void main(String[] args) {
//遍历100以内的所有偶数,并计算所有偶数的和和偶数的个数
int sum =0;
int count =0;
int i = 1;
do{
if(i % 2 == 0){
System.out.println(i);
sum +=i;
count++;
}
i++;
}while(i <= 100);
System.out.println("偶数总和为：" + sum + ",偶数个数为：" + count);
System.out.println("=======================");
int numb = 10; //这里改为12,输出的结果数是一样的（当满足条件运行，输出结果数一致）
while(numb > 10){
System.out.println("while...");
numb--;
}
int numb2 = 10;//这里改为12,输出的是一样的（当满足条件运行，输出结果数一致）
do{
System.out.println("do-while...");
numb2--;
}while(numb2 > 10);
}
}
12、循环结构&关键字break
(1)、break的使用
break语句会终止某个语句块的执行
{
......
break;
......
}
(2)、break语句出现在多层嵌套的语句块中的时候，可以通过标签指明要终止的是哪一层的语句块
label1: { ......
label2: { ......
label3: { ......
break label2;
......
}
}
}
代码演示（break的 “终止” 特征）：
package com.rucoding.d5;
import java.util.Scanner;
/**
* @author LiuYiXin
*
*/
public class BreakDemo01 {
//break关键字的作用: 出现break的时候，会跳出整个循环体
/*
* 练习
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
说明：
1.不在循环条件部分限制次数的结构：while(true) , for(;;)
2.结束循环的几种方式：
方式一：循环条件部分返回false;
方式二：在循环体中，执行break;
*/
public static void main(String[] args) {
//声明Scanner类
Scanner scanner = new Scanner(System.in);
int numZ = 0;
int numF = 0;
//while循环实现
while(true){
System.out.println("请输入合法的整数：");
int num = scanner.nextInt();
if(num > 0){
numZ++;
}else if(num < 0){
numF++;
}else{
break;//跳出整个循环
}
}
System.out.println("输入的正数个数为：" + numZ + ",输入的负数的个数为：" + numF);
//for循环实现
for(;;){
System.out.println("请输入合法的整数：");
int num = scanner.nextInt();
if(num > 0){
numZ++;
}else if(num < 0){
numF++;
}else{
break;//跳出整个循环
}
}
System.out.println("输入的正数个数为：" + numZ + ",输入的负数的个数为：" + numF);
}
}
代码演示（break的 “标签label终止” 特征）：
package com.rucoding.d6;
/**
* @author LiuYiXin
*
*/
public class BreakLableDemo01 {
public static void main(String[] args) {
//演示一下break的标签功能
label:for(int i = 1;i < 3;i++){
for(int j = 1;j < 5;j++){
if(j == 4){
// break;
break label; //break lable直接结束掉外层循环，终止程序。
// continue label; //下面【13要点】会提及
}
System.out.print(j);
}
System.out.println("for lable..."); //break外层循环后，这里不会被打印了。
}
}
}
13、循环结构&关键字continue
continue语句
(1)、continue只能使用在循环结构中;
(2)、continue语句用于跳过其所在循环语句的一次执行，继续执行下一次循环;
(3)、continue语句出现在多层嵌套循环的语句体时，可以通过标签指明要跳过的是哪一层循环 (重点) : 例题可参考【17、代码4】
代码演示（比较break和continue的区别——重点）：
package com.rucoding.d6;
/**
* @author LiuYiXin
*
*/
public class BreakContinueDemo01 {
public static void main(String[] args) {
//演示break和continue的区别
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
// break; //输出123
continue;//输出123567910
// System.out.println();//break、continue后面不能声明执行语句
}
System.out.println(i);
}
System.out.println("============分割线=============");
for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(i % 4 == 0){
// break; //默认跳出包裹此关键字最近的一层循环
continue;
}
System.out.print(j);
}
System.out.println();
}
}
}
小结：
(1)、break只能用于switch语句和循环语句中。
(2)、continue 只能用于循环语句中。
(3)、二者功能类似，但continue是终止本次循环，break是终止本层循环。
(4)、break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
(5)、标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
14、循环结构&关键字return
return : 并非专门用于结束循环的，它的功能是结束一个方法的。当一个方法执行到一个return语句的时候，这个方法将被结束。
与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环内。
15、循环结构&嵌套循环（多重循环）
1、嵌套循环(多重循环)
(1)、将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for、while、do-while均可以作为外层循环或内层循环。
(2)、实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环条件为false时候，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
(3)、假设外层循环的次数为m次，内层为n次，则内层循环的实际上执行m*n 次。
代码演示：
package com.rucoding.d6;
/**
* @author LiuYiXin
*
*/
public class ForDemo03 {
/*
* 嵌套循环的使用：
* 1、嵌套循环：将一个循环结构A声明再另一个循环结构B结构体中，就形成嵌套循环。
*
* 2、外层循环：循环结构B
* 内层循环：循环结构A
* 3、说明：
* ①、内层循环遍历一遍，只相当于外层循环循环体执行一次;
* ②、假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体实际一共执行m*n次
*
* 4、技巧
* 外层循环控制的是行数，内层循环控制的是列数 (重点记住)
*/
public static void main(String[] args) {
//输出五个星号
for(int i=1;i <=5;i++){
System.out.print("*");
}
System.out.println();//换行
//输出5行 5个星号
for(int i=1;i <=5;i++){
for(int j=1;j <=5;j++){
System.out.print("*");
}
System.out.println();
}
System.out.println("========分割线=======");
/*打印如下图案1
* i(外层控制行数) j(内层j控制列数)
** 2 2
*** 3 3
**** 4 4
***** 5 5 即是i=j关系
*/
for(int i=1;i <=5;i++){
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
/* 打印如下图案2
***** i(内层循环控制行数) j(内层循环控制列数)
**** i = 1 j=5
*** i = 2 j=4
**
*
*/
for(int i=1;i <= 5;i++){
for(int j=1;j <= (6-i);j++){
System.out.print("*");
}
System.out.println();
}
System.out.println("========分割线=======");
/*打印如下图案3
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
*/
//分析：
/*
* 先看上半部分
*/
for(int i=1;i <= 5;i++){
for(int j=0;j <= (5-i);j++){
// System.out.print("-"); //上半部分左边的空格， 可以先当做"-"
System.out.print(" ");
}
//控制星号
for(int j=1;j <= i;j++){
System.out.print("*" + " ");
}
System.out.println();
}
//下半部分
for(int i=1;i <= 4;i++){
for(int j=1;j <= i;j++){
// System.out.print("-");//下半部分左边的空格， 可以先当做"-"
System.out.print(" ");
}
//控制星号
for(int j=1;j <= (5-i);j++){
System.out.print(" " + "*" );
}
System.out.println();
}
}
}
16、循环结构&嵌套循环练习1
练习1：打印九九乘法表
代码演示：
package com.rucoding.d6;
/**
* @author LiuYiXin
*
*/
public class Print99Demo01 {
public static void main(String[] args) {
//打印九九乘法表
/*
* 分析九九乘法表构造
* 1 * 1 = 1 i外层控制行数 j内层控制列数
* 2 * 1 = 2 2 * 2 = 4
* ......
* 9 * 1 = 9 9 * 2 = 18 ...... 9 * 9 =81
*/
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(i + " * " + j + " = " + (i*j) + " ");
}
System.out.println();
}
}
}
17、循环结构&嵌套循环练习2
练习2：求100000以内的所有质数个数。
代码1：
package com.rucoding.d6;
/**
* @author LiuYiXin
*
*/
public class PrimeNumberDemo01 {
//求100000以内的所有质数个数
public static void main(String[] args) {
//分析质数(素数)的特点: 只能被1和它本身整除的自然数。
//最小的质数：2
/*
* 拆解：外层循环控制遍历100000以内的数据,内层循环控制 1 到 它本身 减1 的数据
*
*/
boolean isFlag = true;//标识是否被除尽，一旦除尽，修改其值
int count = 0;
long startTime = System.currentTimeMillis();//计算程序执行时间
for(int i = 2;i <= 100000;i++){
for(int j = 2;j < i;j++){// 此时j的作用：能否被i整除
//
if(i % j == 0){ //判断i除以j，只要有一个能整除 就设置isFlag为false
isFlag = false;
}
}
if(isFlag == true){
// System.out.println(i);
count++;
}
isFlag = true; //重置flag
}
long endTime = System.currentTimeMillis();
System.out.println("100000以内的质数一共有：" + count + " 个");
System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");
}
}
【代码1】运行结果:
100000以内的质数一共有：9592 个
计算耗时：11000 毫秒
这运行有点费时，得优化。
代码2【针对代码1的优化】：
注意代码出现的 “优化点1”。
package com.rucoding.d6;
/**
* @author LiuYiXin
*
*/
public class PrimeNumberDemo02 {
//求100000以内的所有质数个数
public static void main(String[] args) {
//分析质数(素数)的特点: 只能被1和它本身整除的自然数。
//最小的质数：2
/*
* 拆解：外层循环控制遍历100000以内的数据,内层循环控制 1 到 它本身 减1 的数据
*
*/
boolean isFlag = true;//标识是否被除尽，一旦除尽，修改其值
int count = 0;
long startTime = System.currentTimeMillis();//计算程序执行时间
for(int i = 2;i <= 100000;i++){
for(int j = 2;j < i;j++){// 此时j的作用：能否被i整除
//优化点1：这里假如是非质数i为10,
//那么此时j的循环是2,3,4..9 (第一个2的时候已经满足除尽的，后面就没必要再执行了)
if(i % j == 0){ //判断i除以j，只要有一个能整除 就设置isFlag为false
isFlag = false;
break;//第一个进来满足除尽了，后面的数字没必要再进行一遍整除了。
}
}
if(isFlag == true){
// System.out.println(i);
count++;
}
isFlag = true; //重置flag
}
long endTime = System.currentTimeMillis();
System.out.println("100000以内的质数一共有：" + count + " 个");
System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");
}
}
【代码2】运行结果:
100000以内的质数一共有：9592 个
计算耗时：1078 毫秒
继续观察，发现是还可以进行优化的。
代码3【针对代码2的优化】：
注意代码出现的 “优化点2”。
package com.rucoding.d6;
/**
* @author LiuYiXin
*
*/
public class PrimeNumberDemo03 {
//求100000以内的所有质数个数
public static void main(String[] args) {
//分析质数(素数)的特点: 只能被1和它本身整除的自然数。
//最小的质数：2
/*
* 拆解：外层循环控制遍历100000以内的数据,内层循环控制 1 到 它本身 减1 的数据
*
*/
boolean isFlag = true;//标识是否被除尽，一旦除尽，修改其值
int count = 0;
long startTime = System.currentTimeMillis();//计算程序执行时间
for(int i = 2;i <= 100000;i++){
for(int j = 2;j <= Math.sqrt(i);j++){// 此时j的作用：能否被i整除
//优化点2：这里的循环条件部分(j < i) ,范围可以缩减，刚开始考虑的i/2，缩减了一半，后面再观察考虑一下，开根号可以大大缩减，实在秒啊！
//优化点1：这里假如是非质数i为10,
//那么此时j的循环是2,3,4..9 (第一个2的时候已经满足除尽的，后面就没必要再执行了)
if(i % j == 0){ //判断i除以j，只要有一个能整除 就设置isFlag为false
isFlag = false;
break;//优化点1：第一个进来满足除尽了，后面的数字没必要再进行一遍整除了。
}
}
if(isFlag == true){
// System.out.println(i);
count++;
}
isFlag = true; //重置flag
}
long endTime = System.currentTimeMillis();
System.out.println("100000以内的质数一共有：" + count + " 个");
System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");
}
}
【代码3】运行结果:
100000以内的质数一共有：9592 个
计算耗时：15 毫秒
继续优化，代码看着不太友好。
代码4【针对以上代码的优化】：
Tip：此处利用了continue标签。
package com.rucoding.d6;
/**
* @author LiuYiXin
*
*/
public class PrimeNumberDemo04 {
//求100000以内的所有质数个数
public static void main(String[] args) {
//分析质数(素数)的特点: 只能被1和它本身整除的自然数。
//最小的质数：2
/*
* 拆解：外层循环控制遍历100000以内的数据,内层循环控制 1 到 它本身 减1 的数据
*
*/
int count = 0;
long startTime = System.currentTimeMillis();//计算程序执行时间
label:for(int i = 2;i <= 100000;i++){
for(int j = 2;j <= Math.sqrt(i);j++){// 此时j的作用：能否被i整除
//
if(i % j == 0){ //判断i除以j，能否除尽
continue label;//可以除尽的话，直接后面不用继续了，跳出当前的循环，继续下一次循环
}
}
//能走到这里， 证明已经是质数了。
count++;
}
long endTime = System.currentTimeMillis();
System.out.println("100000以内的质数一共有：" + count + " 个");
System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");
}
}
【代码4】运行结果:
100000以内的质数一共有：9592 个
计算耗时：13 毫秒