JAVA语言语法_流程控制（part3）

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 毫秒