Java基础编程之分支结构和循环结构

知识点1：分支结构1：if-else

• 基本使用

/*
一、流程控制分为三类结构：顺序结构、分支结构、循环结构

二、分支结构1：if-else

1.格式1：
if(条件表达式){
	执行语句1;
}

2.格式2：“二选一”

if(条件表达式){
	执行语句1;
}else{
	执行语句2;
}

3.格式3：“多选一”

if(条件表达式1){
	执行语句1;
}else if(条件表达式2){
	执行语句2;
}else if(条件表达式3){
	执行语句3;
}
....
else{
	执行语句2;
}
*/

class IfTest {
	public static void main(String[] args) {
		
		
		int heartBeats = 80;
		if(heartBeats < 60 || heartBeats > 100){
			System.out.println("你需要做进一步的检查");
		}

		System.out.println("体检结束");
		
		//############二选一################
		int age = 23;
		if(age >= 22){
			System.out.println("你已经到了合法的结婚年龄");
		}else{
			System.out.println("你只能先谈谈恋爱~~");
		}
		
		//############多选一################
		int myAge = 12;
		if(myAge < 0 || myAge > 150){
			System.out.println("你输入的数据不合法~~");	
		}else if(myAge < 6){
			System.out.println("婴幼儿时期");
		}else if(myAge < 25){
			System.out.println("青少年时期");
		}else if(myAge < 60){
			System.out.println("壮年时期");
		}else{
			System.out.println("老年时期");
		}
 
 		System.out.println("执行结束");
	}
}

• 例题

说明1：
如果多个条件表达式彼此之间是“互斥”关系（即：没有交集），则哪个条件表达式声明在上面，哪个条件表达式声明在下面都可以。
如果多个条件表达式彼此之间是“包含”关系，则需要将条件表达式范围小的声明在条件表达式范围大的上面。

说明2：如果if-else结构中的某一个if或else if 或 else只有一行执行语句，则可以省略其一对{}。但是，不建议省略
*/

/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。

请从键盘输入岳小鹏的期末成绩，并加以判断


import java.util.Scanner;
class  IfTest1{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入岳小鹏的期末成绩：");

		int score = scan.nextInt();
		
		if(score == 100){
			System.out.println("奖励一台BMW");
		}else if(score > 80){//
			System.out.println("奖励一台iphone xs max");
			
		}else if(score >= 60 ){//
			System.out.println("奖励一个 iPad");
			
		}else{
			System.out.println("奖励一本参考书");
		}

	}
}

知识点2：if-else的使用

• 代码举例

/*
大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，
当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。

如果这三个条件同时满足，则：“我一定要嫁给他!!!”

如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”

如果三个条件都不满足，则：“不嫁！”

*/
import java.util.Scanner;
class IfTest {
	public static void main(String[] args) {
		/*
		Scanner scann = new Scanner(System.in);

		System.out.println("请输入你的身高(cm):");
		int height = scann.nextInt();

		System.out.println("请输入你的财富(单位：千万):");
		double wealth = scann.nextDouble();

		System.out.println("请告诉我，你帅否？(true/false):");
		boolean isHandsome = scann.nextBoolean();

		if(height >= 180 && wealth >= 1 && isHandsome){
			System.out.println("我一定要嫁给他!!!");

		}else if(height >= 180 || wealth >= 1 || isHandsome){
			System.out.println("嫁吧，比上不足，比下有余。");

		}else{
			System.out.println("不嫁！");

		}
		*/

		//方式二：使用了String的equals()，判断两个字符串是否相等
		Scanner scann = new Scanner(System.in);

		System.out.println("请输入你的身高(cm):");
		int height = scann.nextInt();

		System.out.println("请输入你的财富(单位：千万):");
		double wealth = scann.nextDouble();

		System.out.println("请告诉我，你帅否？(是/否):");
		String isHandsome = scann.next();

		if(height >= 180 && wealth >= 1 && "是".equals(isHandsome)){
			System.out.println("我一定要嫁给他!!!");

		}else if(height >= 180 || wealth >= 1 || "是".equals(isHandsome)){
			System.out.println("嫁吧，比上不足，比下有余。");

		}else{
			System.out.println("不嫁！");

		}
	}
}

知识点3：switch-case的使用

/*
分支结构2：switch-case

switch(表达式){

case 常量1:
	执行语句1;
	break;
case 常量2:
	执行语句2;
	break;
case 常量3:
	执行语句3;
	break;

...

default :
	执行语句n;
	break;
}

说明：
1. 执行过程：根据switch中表达式的值，依次匹配各个case中的常量。当与某个常量匹配上时，就进入case中，调用其执行语句。
执行完之后，仍然会考虑继续执行其后的case中的结构，直到遇到break关键字或执行完后续的所有的case结构。

2. switch中的表达式可以是如下的类型：byte \ short \ char \ int ; 枚举类(jdk5.0新增) \ String(jdk7.0新增)

3. switch-case结构的局限性：① switch中的表达式有类型的限制  ② 匹配的多个case，通常都不会太多。

4. default相当于if-else结构中的else。
   default是可选的，位置也是灵活的。

5. switch-case与if-else的转换：
	switch-case结构一定可以改写为if-else;
	if-else不一定能改写成switch-case.
	建议：在switch-case和if-else都可以使用的场景下，建议大家使用switch-case。因为执行效率稍高
*/

• 代码举例

class SwitchCaseTest {
	public static void main(String[] args) {
		int num = 5;

		switch(num){
		
		case 0:
			System.out.println("zero");
			break;
		case 1:
			System.out.println("one");
			break;
		case 2:
			System.out.println("two");
			break;//跳出当前switch-case结构
		case 3:
			System.out.println("three");
			break;
		case 4:
			System.out.println("four");
			break;
		default:
			System.out.println("other");
			//break;
		}

		//表达式是String类型
		String season = "summer";
		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;
		}

	}
}

• 如下：多个case结构可以合并

/*
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

结论：如果多个case的执行语句相同，可以考虑合并。
*/
class SwitchCaseTest1{
	public static void main(String[] args) {
		int score = 78;
		if(score < 60){
			
			System.out.println("不及格");
		}else{
			
			System.out.println("及格");
		}
		
		//switch-case
		/*
		switch(score){
		case 0:
			//...
		case 1:
			//...
		case 2:
			//...
		//...
		case 100:
			//...
		}
		*/

		switch(score / 10){
		case 0:
		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;

		}

		//更优的做法：
		switch(score / 60){
		case 0:
			System.out.println("不及格");
			break;
		case 1:
			System.out.println("及格");
			break;

		}
	}
}

• 如下：switch-case结构中没有break的举例

/*
编写程序：从键盘上输入2020年的“month”和“day”，要求通过程序输出输入的日期为2020年的第几天。
*/
import java.util.Scanner;
class SwitchCaseTest2{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);


		System.out.println("请输入当年的month：");
		int month = scan.nextInt();
		System.out.println("请输入当月的day：");
		int day = scan.nextInt();
		
		
		int sumDays = 0;//记录总天数
		/*
		不建议如下的操作：
		switch(month){//1 - 12
		case 1:
			sumDays = day;
			break;
		case 2:
			sumDays = 31 + day;
			break;
		case 3:
			sumDays = 31 + 29 + day;
			break;
		case 4:
			sumDays = 31 + 29 + 31 + day;
			break;
		//...
		
		}
		*/
		//更优的操作
		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:
			sumDays += 29;
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;	
		}
		
		System.out.println(month + "月" + day + "日是2020年的第" + sumDays + "天");

	}
}

/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
 
   注：判断一年是否是闰年的标准：
       1）可以被4整除，但不可被100整除
	或
       2）可以被400整除

*/
import java.util.Scanner;
class SwitchCaseTest3 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入年份year：");
		int year = scan.nextInt();
		System.out.println("请输入当年的month：");
		int month = scan.nextInt();
		System.out.println("请输入当月的day：");
		int day = scan.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:
			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(month + "月" + day + "日是2020年的第" + sumDays + "天");

	}
}

知识点4：循环结构1：for

/*
一、凡是循环结构，都有如下的4个要素：

① 初始化条件部分
② 循环条件部分  ---> boolean类型
③ 循环体部分
④ 迭代部分

二、for循环结构

for(①;②;④){
	③
}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ② - ... - ② 

*/

• 代码举例

class ForTest {
	public static void main(String[] args) {

		for(int i = 1;i <= 5;i++){
			System.out.println("Hello World!");
		}
		

		//例子：遍历100以内的偶数,并计算所有偶数的和，及记录偶数的个数
		int sum = 0;//记录总和
		int count = 0;//记录偶数的个数
		for(int i = 0;i <= 100;i++){
			if(i % 2 == 0){
				System.out.println(i);
				sum += i;
				count++;
			}
			
		}

		System.out.println("总和为：" + sum);
		System.out.println("偶数的个数为：" + count);

	}
}

• 如下：在循环中使用break

/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用


1. 总结：结束循环的方式都有哪些呢？
	方式1：循环条件不满足，返回false
	方式2：在循环结构中，使用break关键字跳出循环结构


2. 如果一个循环结构不断的被执行，没有终止。则称为死循环！
3. 开发中大家要避免出现死循环。
*/

class ForTest1 {
	public static void main(String[] args) {
		
		int m = 12;
		int n = 20;
		
		//##########求最大公约数###############
		//获取两个数的较小值
		int min = (m > n)? n : m;

		for(int i = min;i >= 1;i--){
			if(m % i == 0 && n % i == 0){
				System.out.println("最大公约数：" + i);
				break;//结束当前循环结构
			}

		}
		
		//###########求最小公倍数##############
		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;
			}
		}
	
	}
}

知识点5：循环结构2：while

/*
一、凡是循环结构，都有如下的4个要素：

① 初始化条件部分
② 循环条件部分  ---> boolean类型
③ 循环体部分
④ 迭代部分

二、while循环的结构

①
while(②){
	③
	④
}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ② - ... - ② 


三、说明
1. for循环和while循环是可以相互转换的。
2. 关于初始化条件部分，while循环在执行结束以后，初始化条件中涉及到的变量仍然可用。 而for循环的初始化条件中定义的变量，在出了循环结构以后失效。

*/

class WhileTest {
	public static void main(String[] args) {
		
		//遍历100以内的偶数,并计算所有偶数的和，及记录偶数的个数
		int i = 0;
		int sum = 0;//记录总和
		int count = 0;//记录偶数的个数
		while(i <= 100){
			if(i % 2 == 0){
				System.out.println(i);
				sum += i;
				count++;
			}
			//迭代条件
			i++;
		}
		System.out.println(i);//101
		System.out.println("偶数总和为：" + sum);
		System.out.println("偶数个数为：" + count);
	}
}

知识点5：循环结构3：do-while

/*
一、凡是循环结构，都有如下的4个要素：

① 初始化条件部分
② 循环条件部分  ---> boolean类型
③ 循环体部分
④ 迭代部分


二、do-while循环的结构

①
do{
	③
	④
}while(②);

执行过程：① - ③ - ④ - ② - ③ - ④ - ② - ③ - .... - ②

三、说明：
1. do-while循环至少会执行一次循环体。
2. 从开发的使用频率讲，do-while用的较少。
*/

class DoWhileTest {
	public static void main(String[] args) {
		//遍历100以内的偶数,并计算所有偶数的和，及记录偶数的个数
		int i = 0;
		int sum = 0;//记录总和
		int count = 0;//记录个数
		do{
			if(i % 2 == 0){
				System.out.println(i);
				sum += i;
				count++;
			}
			i++;//迭代条件
		}while(i <= 100);

		System.out.println("偶数总和为：" + sum);
		System.out.println("偶数个数为：" + count);
	}
}

知识点6：while(true)、for( ; ; )

/*
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

最简单“无限” 循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，
需要根据循环体内部某些条件，来控制循环的结束。

*/

import java.util.Scanner;
class ForWhileTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int positiveNumber = 0;//记录正数的个数
		int negativeNumber = 0;//记录负数的个数

		while(true){//for(;;){
			System.out.println("请输入一个整数：（输入0时，结束）");
			int num = scan.nextInt();

			if(num == 0){
				break;
			}else if(num > 0){
				positiveNumber++;
			}else{
				negativeNumber++;
			}
		}
		
		System.out.println("正数的个数为：" + positiveNumber);
		System.out.println("负数的个数为：" + negativeNumber);
	}
}

• 退出循环结构的两种方式：
  • 循环条件返回为false
  • 在循环体中执行break

知识点7：嵌套循环

• 理解

/*

测试嵌套循环

1. 将一个循环结构A声明在另一个循环结构B的循环体中，则构成了嵌套循环。
   A:内层循环
   B:外层循环

2. 技巧：外层循环控制行数，内层循环控制列数

3. 如果外层循环循环次数为m次，内层循环循环次数为n次。则可以理解为内层循环的循环体要执行m * n次
*/

• 基本使用

class ForForTest {
	public static void main(String[] args) {
		//******
		for(int i = 1;i <= 6;i++){
			System.out.print("*");
		}

		System.out.println();
		System.out.println();


		/*

		******
		******
		******
		******
		******

		*/
		for(int j = 1;j <= 5;j++){
			for(int i = 1;i <= 6;i++){
				System.out.print("*");
			}

			System.out.println();

		}

		/*
				i		j
		*		1		1
		**		2		2	
		***		3		3
		****	4		4
		*****	5		5

		*/
		for(int i = 1;i <= 5;i++){
			for(int j = 1;j <= i;j++){
				System.out.print("*");
			}
			System.out.println();
		}

		/*
					i		j(*的个数)			j = 5 - i;
		****		1		4
		***			2		3
		**			3		2
		*			4		1

		*/
		for(int i = 1;i <= 4;i++){
			for(int j = 1;j <= 5 - i;j++){
				System.out.print("*");
			}
			System.out.println();
		}

		/*

*
**
***
****
*****

****
***
**
*
		
		*/
		//如上的做法

/*

上半部分		i		j(-)		k(*)
----*			1		4			1
---* *			2		3			2
--* * *			3		2			3
-* * * *		4		1			4
* * * * *		5		0			5

下半部分
 * * * * 
  * * * 
   * * 
    * 

*/		//上半部分
		for(int i = 1;i <= 5;i++){
			for(int j = 1;j <= 5 - i;j++){
				System.out.print(" ");
			}
			for(int k = 1;k <= i;k++){
				System.out.print("* ");
			}
			System.out.println();
		}

	}
}

• 九九乘法表

/*
九九乘法表的实现：
1 * 1 = 1
1 * 2 = 2  2 * 2 = 4
...

1 * 9 = 9     ...   9 * 9 = 81


*/
class NineNineTable {
	public static void main(String[] args) {
		for(int i = 1;i <= 9;i++){
			
			for(int j = 1;j <= i;j++){
				
				System.out.print(j + " * " + i + " = " + (j * i) +"  ");
			}
			
			System.out.println();
		}
	}
}

• 质数输出

/*
遍历100000以内所有的质数。

体会一下不同的算法，执行效率的差别。

*/
class PrimeNumberTest1 {
	public static void main(String[] args) {
		
		//获取系统当前的毫秒数
		long start = System.currentTimeMillis();

		boolean isFlag = true;
		int count = 0;//记录质数的个数
		for(int i = 2;i <= 100000;i++){
			
			//优化2：修改判断的临界值
			for(int j = 2;j <= Math.sqrt(i);j++){//for(int j = 2;j < i;j++){//让j被i除
				
				if(i % j == 0){
					isFlag = false;
					break;//优化1:主要针对的是非质数
				}

			}

			//判断isFlag是否曾经被赋值为false
			if(isFlag){//if(isFlag == true){
				//System.out.println(i);
				count++;
			}

			//重置isFlag
			isFlag = true;
		}
		System.out.println("质数的个数为：" + count);
		//获取系统当前的毫秒数
		long end = System.currentTimeMillis();
		
		System.out.println("花费的总时间为(毫秒)：" + (end - start));//17683 - 1930 - 736
		//13017 - 12

	}
}

知识点8：break、continue

break的使用范围：
1. 应用在switch-case结构中，一旦执行，就跳出当前switch-case结构
2. 应用在循环结构中，一旦执行，就跳出前的循环结构

/*
break和continue的使用

			使用场景			在循环结构中使用的作用：			相同点
break		① switch-case
			② 循环结构			结束当前循环结构					在其后，不能声明执行语句。否则，编译错误

continue	① 循环结构			结束当次循环结构					在其后，不能声明执行语句。否则，编译错误

*/

class BreakContinueTest {
	public static void main(String[] args) {
		
		for(int i = 1;i <= 10;i++){
			
			if(i % 4 == 0){
				//break;//结束当前循环
				continue;//结束当次循环

				//是否可以声明执行语句：No!
				//System.out.println("今晚迪丽热巴要约我。。。。");
			}

			System.out.print(i);
		}
		
		System.out.println("#####################");
		
		
		//##################################
		label:for(int i = 1;i <= 4;i++){
			
			for(int j = 1;j <= 10;j++){
				
				if(j % 4 == 0){
					//break;
					//continue;

					//break label;
					continue label;
				}

				System.out.print(j);

			}
			System.out.println();

		}
	}
}

补充：如何获取指定范围的随机数

/*
如何获取一个随机数？

1. 通过调用Math.random()，可以获取一个[0,1)范围的内的double型的随机数

2. 获取[10,99]范围内的随机数？
int number = (int)(Math.random() * 90 + 10);

3. 获取[100,999]范围内的随机数？
int number = (int)(Math.random() * (999-100+1) + 100);

总结：获取[a,b]范围的随机数？
 (int)(Math.random() * (b - a + 1) + a);
*/
class RandomNumberTest{
	public static void main(String[] args) {
		//double value = Math.random();
		//System.out.println("随机数为：" + value);

		//int number = (int)(Math.random() * 90 + 10);//[0,1) --> [0,90) ---> [10,100) --> [10,99]
		//System.out.println("随机数为：" + number);

		int number = (int)(Math.random() * (999-100+1) + 100); //[0,1) -->[0,900) --> [100,1000) -->[100,999]
	}
}