6.流程控制

6.流程控制
📋 个人简介
💖 作者简介：大家好，我是W_chuanqi，一个编程爱好者
📙 个人主页：W_chaunqi
😀 支持我：点赞👍+收藏⭐️+留言📝
💬 愿你我共勉：“没有什么比勇气更温文尔雅，没有什么比怯懦更冷酷无情!”✨✨✨
文章目录
一、选择结构语句

在实际生活中经常需要做出一些判断，比如开车来到一个十字路口，就需要对红绿灯进行判断，如果前面是红灯，就停车等候，如果是绿灯，就通行。Java中有一种特殊的语句叫做选择语句，它也需要对一些条件做出判断，从而决定执行哪一段代码。选择语句分为if条件语句和switch条件语句。

1 if条件语句

 1.1 if语句

if语句是指如果满足某种条件，就进行某种处理。例如，小明妈妈跟小明说“如果你考试得了100分，星期天就带你去游乐场玩”。这句话可以通过下面的一段伪代码来描述。
```
如果小明考试得了100分
	妈妈星期天带小明去游乐场
1
2
```
在上面的伪代码中，“如果”相当于Java中的关键字if，“小明考试得了100分”是判断条件，需要用()括起来，“妈妈星期天带小明去游乐场”是执行语句，需要放在{}中。修改后的伪代码如下：
```
if (小明考试得了100分) {
	妈妈星期天带小明去游乐场
}
1
2
3
```
通过上面的伪代码可以总结出if语句的格式：
```
if (条件语句)//这里的条件必须用小括号括起来。
{ 
	代码块
}
1
2
3
4
```
接下来通过一个案例学习if语句的具体用法。
```
public class Example07 {
	public static void main(String[] args) {
		int x = 5;
		if (x < 10) {
			x++;
		}
		System.out.println("x=" + x);
	}
}
1
2
3
4
5
6
7
8
9
```
案例运行结果如下图。

上述代码中，第3行代码定义了一个变量x，初始值为5。第4~6行代码在if语句中判断x的值是否小于10，如果x小于10，就执行x++。由于x值为5，x<10条件成立，{}中的语句会被执行，变量x的值进行自增。从运行结果可以看出，x的值已由原来的5变成了6。

1.2 if…else语句

if…else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理。例如，要判断一个正整数的奇偶，如果该数字能被2整除则是一个偶数，否则该数字就是一个奇数。

if…else语句具体语法格式如下:
```
if (判断条件){
	执行语句1
	...
}
else{
	执行语句2
	...
}
1
2
3
4
5
6
7
8
```
接下来通过一个案例实现判断奇偶数的程序。
```
public class Example08 {
	public static void main(String[] args) {
		int num = 19;
		if (num % 2 == 0) {
			// 判断条件成立，num被2整除
			System.out.println("num是一个偶数");
		} else {
			System.out.println("num是一个奇数");
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
```
程序运行结果如下图。

上述代码中，第3行代码定义了变量num，num的初始值为19；第4~9行代码判断num%2的值是否为0，如果为0则输出“num是一个偶数”，否则输出“num的值是一个奇数”。由于num的值为19，与2取模的结果为1，不等于0，判断条件不成立。因此程序执行else后面{}中的语句，打印“num是一个奇数”。

1.3 if…else if…else语句

if…else if…else语句用于对多个条件进行判断，进行多种不同的处理。例如，对一个学生的考试成绩进行等级划分，如果分数大于80分，则等级为优；如果分数大于70分，则等级为良；如果分数大于60分，则等级为中；如果分数小于60分，则等级为差。

if…else if…else语句格式：
```
if (判断条件1) {
	执行语句1
} 
else if (判断条件2) {
	执行语句2
}
...
else if (判断条件n) {
	执行语句n
}
else {
	执行语句n+1
}
1
2
3
4
5
6
7
8
9
10
11
12
13
```
上述格式中，判断条件是一个布尔值。当判断条件1为true时，if后面{}中的执行语句1会执行。当判断条件1为false时，会继续执行判断条件2，如果判断条件2为true则执行语句2…，以此类推，如果所有的判断条件都为false，则意味着所有条件均不满足，else后面{}中的执行语句n+1会执行。

接下来通过一个案例演示if…else if…else语句的用法，该案例实现对学生考试成绩进行等级划分的程序。
```
public class Example09 {
	public static void main(String[] args) {
		int grade = 75; 		// 定义学生成绩
		if (grade > 80) {// 满足条件 grade > 80
			System.out.println("该成绩的等级为优");
		} else if (grade > 70) {// 不满足条件 grade > 80 ，但满足条件 grade > 70 
			System.out.println("该成绩的等级为良");
		} else if (grade > 60) {// 不满足条件 grade > 70 ，但满足条件 grade > 60 
			System.out.println("该成绩的等级为中");
		} else {// 不满足条件 grade > 60 
			System.out.println("该成绩的等级为差");
		}    
	}    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
运行结果如下：

2 三元运算符

Java提供了一个三元运算符，可以同时操作三个表达式。三元运算符语法格式如下所示：
```
判断条件 ? 表达式1 : 表达式2
1
```
在上述语法格式中，当判断条件成立时，计算表达式1的值作为整个表达式的结果，否则计算表达式2的值作为整个表达式的结果。

三元运算符比if…else语句更简洁。例如，求两个数x、y中的较大者，分别使用if…else语句和三元运算符实现。
```
//if…else语句
int x = 0;
int y = 1;
int max;
if (x > y) {
	max = x;
} else {
	max = y;}
System.out.println(max);
1
2
3
4
5
6
7
8
9
```
```
//三元运算符
int x = 0;
int y = 1;
max = x > y? x : y;
System.out.println(max);
1
2
3
4
5
```
使用三元运算符时需要注意以下几点：
（1）条件运算符“？”和“：”是一对运算符，不能分开单独使用。
（2）条件运算符的优先级低于关系运算符与算术运算符，但高于赋值运算符。
（3）条件运算符可以进行嵌套，结合方向自右向左。例如，a>b?a:c>d?c:d应该理解为a>b?a:(c>d?c:d)，这也是条件运算符的嵌套情形，即三元表达式中的表达式2又是一个三元表达式。

3 switch条件语句

switch 条件语句也是一种很常用的选择语句，和if条件语句不同，它只能针对某个表达式的值做出判断，从而决定程序执行哪一段代码。例如，在程序中使用数字1~7表示星期一到星期天，如果想根据输入的数字输出对应中文格式的星期值，可以通过下面的一段伪代码来描述：
```
用于表示星期的数字
	如果等于1，则输出星期一
	如果等于2，则输出星期二
	如果等于3，则输出星期三
	如果等于4，则输出星期四
	如果等于5，则输出星期五
	如果等于6，则输出星期六
	如果等于7，则输出星期天
1
2
3
4
5
6
7
8
```
上述伪代码，如果使用if…else语句实现，则代码太过繁琐，不便于阅读。为此，Java提供了switch语句实现这种需求，switch语句使用switch关键字描述一个表达式，使用case关键字描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，就执行对应case下的语句。
```
	switch (表达式){
	case 目标值1:
		执行语句1
		break;
	case 目标值2:
		执行语句2
		break;
	．．．．．．
	case 目标值n:
		执行语句n
		break;
	default:
		执行语句n+1
		break;      }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
switch语句将表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，则执行对应case后面的语句；如果没找到任何匹配的值，则执行default后的语句。switch语句中的break关键字将在后面的小节中做具体介绍，此处，初学者只需要知道break的作用是跳出switch语句即可。

接下来通过一个案例来演示switch语句的用法，在该案例中，使用switch语句根据给出的数值输出对应中文格式的星期。
```
public class Example10{
	public static void main(String[] args) {
		int week = 5;
	    switch (week) {
	    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;
		default:
			System.out.println("输入的数字不正确...");
			break;
		}
	}
}    
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
```
上述程序运行结果如下图。

在使用switch语句时，如果多个case条件后面的执行语句是一样的，则执行语句只需书写一次即可。例如，要判断一周中的某一天是否为工作日，同样使用数字1~7表示星期一到星期天，当输入的数字为1、2、3、4、5时就视为工作日，否则就视为休息日。
```
public class Example11 {
	public static void main(String[] args) {
		int week = 2;
		switch (week) {
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
	 // 当 week 满足值 1、2、3、4、5 中任意一个时，处理方式相同
				System.out.println("今天是工作日");
				break;
			case 6:
			case 7:
	// 当 week 满足值 6、7 中任意一个时，处理方式相同
				System.out.println("今天是休息日");
				break;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
```
上述程序运行结果如下图。

二、循环结构语句

 1 while循环语句

while循环语句与选择结构语句类似，都是根据判断条件决定是否执行大括号内的执行语句。区别在于，while语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环结束。

while循环语句的语法结构如下：
```
while(循环条件){
执行语句
...
}
1
2
3
4
```
在上面的语法结构中，{}中的执行语句被称作循环体，循环体是否执行取决于循环条件。当循环条件为true时，循环体就会执行。循环体执行完毕，程序继续判断循环条件，如果条件仍为true则继续执行循环体，直到循环条件为false时，整个循环过程才会结束。

接下来通过打印1~4之间的自然数演示while循环语句的用法。
```
public class Example12 {
	public static void main(String[] args) {
		int x = 1;          		// 定义变量x，初始值为1
		while (x <= 4) {  	// 循环条件
			System.out.println("x = " + x); 	// 条件成立，打印x的值
			x++;           	// x进行自增
		}
	}
}
1
2
3
4
5
6
7
8
9
```
程序运行结果如下图。

上述代码中，第3行代码定义了变量x，初始值为1。在满足循环条件x <= 4的情况下，循环体会重复执行，打印x的值并让x自增。由运行结果可知，打印结果中x的值分别为1、2、3、4。需要注意的是，文件中第6行代码在每次循环时改变变量x的值，从而达到最终改变循环条件的目的。如果没有这行代码，x的值一直为1，整个循环会进入无限循环的状态，永远不会结束。

2 do…while循环语句

do…while循环语句和while循环语句功能类似，语法结构如下：
```
do {
执行语句
...
} while(循环条件);
1
2
3
4
```
在上面的语法结构中，关键字do后面{}中的执行语句是循环体。do…while循环语句将循环条件放在了循环体的后面。这也就意味着，循环体会无条件执行一次，然后再根据循环条件决定是否继续执行。

接下来使用do…while循环语句输出1~4之间的自然数。
```
public class Example13 {
	public static void main(String[] args) {
		int x = 1;          		// 定义变量x，初始值为1
		do {
			System.out.println("x = " + x); // 打印x的值
			x++;            	// 将x的值自增
		} while (x <= 4); 	// 循环条件
	}
}
1
2
3
4
5
6
7
8
9
```
程序运行结果如下图。

3 for循环语句

for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。

for循环语句的语法格式如下：
```
for（初始化表达式; 循环条件; 操作表达式）
{
	执行语句
	...
}
1
2
3
4
5
```
在上面的语法格式中，for关键字后面()中包括了三部分内容：初始化表达式、循环条件和操作表达式，它们之间用（;）分隔，{}中的执行语句为循环体。

执行流程：
- 第一步，执行初始化表达式
- 第二步，执行循环条件，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
- 第三步，执行循环体
- 第四步，执行操作表达式，然后重复执行第二步
- 第五步，退出循环
接下来对自然数1~4求和演示for循环的使用。
```
public class Example14 {
	public static void main(String[] args) {
		int sum = 0;   			// 定义变量sum，用于记住累加的和
		for (int i = 1; i <= 4; i++) {       	// i的值会在1~4之间变化
			sum += i; 		// 实现sum与i的累加
		}
		System.out.println("sum = " + sum); // 打印累加的和
	}
}
1
2
3
4
5
6
7
8
9
```
程序运行结果如下图。

在上述程序中，变量i的初始值为1，在判断条件i<=4结果为true的情况下，执行循环体sum+=i；执行完毕后，执行操作表达式i++，i的值变为2，然后继续进行条件判断，开始下一次循环，直到i=5时，判断条件i<=4结果为false，循环结束，执行for循环后面的代码，打印“sum=10”。

每次循环中变量sum和i的值的变化如下表。

循环次数 i sum
第一次 1 1
第二次 2 3
第三次 3 6
第四次 4 10

4 foreach语句

foreach 语句是 for 语句的特殊简化版本，不能完全取代 for 语句，但任何 foreach 语句都可以改为 for 语句版本。foreach 并不是一个关键字，习惯上将这种特殊的 for 语句格式称为 foreach 语句。foreach语句在遍历数组等方面为程序员提供了很大的方便。语法如下:
```
for(元素类型 x:遍历对象 objX){
    引用了 x 的java 语句;
}
1
2
3
```
foreach 语句中的元素变量x，不必对其进行初始化。下面通过简单的例子来介绍 foreach 语句是如何遍历一维数组的。

使用 foreach 语句遍历整型数组
```
public class Repetition {
	public static void main(String[] args) {
		int arr[] = { 5, 13, 96 };// 一维整形数组
		System.out.println("一维数组中的元素分别为:");
		// x 的类型与 arr 元素的类型相同。for 循环依次取出 arr 中的值并赋给 x
		for (int x : arr) {
			System.out.println(x);// 输出遍历出的元素值
		}
	}
}
1
2
3
4
5
6
7
8
9
10
```
运行结果如下：

5 循环嵌套

循环嵌套是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，其中最常见的是在for循环中嵌套for循环，格式如下：
```
for(初始化表达式; 循环条件; 操作表达式) {
	...
	for(初始化表达式; 循环条件; 操作表达式) {
		执行语句
		...
	}
	...
}
1
2
3
4
5
6
7
8
```
接下来通过使用“*”打印直角三角形演示for循环嵌套的使用。
```
public class Example15 {
	public static void main(String[] args) {
		int i, j;                           		// 定义两个循环变量
		for (i = 1; i <= 9; i++) {      	// 外层循环
			for (j = 1; j <= i; j++) { 	// 内层循环
				System.out.print("*"); 	// 打印*
			}
			System.out.print("\n");     // 换行
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
```
程序运行结果如下图。

下面分步骤讲解循环过程，具体如下：
- 第一步，第3行代码定义了两个循环变量i和j，其中i为外层循环变量，j为内层循环变量。
- 第二步，第4行代码将i初始化为1，判断条件为i <= 9为true，首次进入外层循环的循环体。
- 第三步，第5行代码将j初始化为1，由于此时i的值为1，条件j <= i为true，首次进入内层循环的循环体，打印一个“*”。
- 第四步，执行第5行代码中内层循环的操作表达式j++，将j的值自增为2。
- 第五步，执行第5行代码中的判断条件j<=i，判断结果为false，内层循环结束。执行第8行代码，打印换行符。
- 第六步，执行第4行代码中外层循环的操作表达式i++，将i的值自增为2。
- 第七步，执行第4行代码中的判断条件i<=9，判断结果为true，进入外层循环的循环体，继续执行内层循环。
- 第八步，由于i的值为2，内层循环会执行两次，即在第2行打印两个“*”。在内层循环结束时会打印换行符。
- 第九步，以此类推，在第3行会打印3个“*”，逐行递增，直到i的值为10时，外层循环的判断条件i <= 9结果为false，外层循环结束，整个循环也就结束了。
6 循环控制语句

 6.1 break语句

在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行循环后面的代码。
```
public class Example16 {
	public static void main(String[] args) {
		int x = 1;                             // 定义变量x，初始值为1
		while (x <= 4) {                    // 循环条件
			System.out.println("x = " + x); // 条件成立，打印x的值
			if (x == 3) {
				break;
			}
			x++;                          // x进行自增
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
```
程序运行结果如下图。

当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环，则需要在外层循环中使用break语句。
```
public class Example17 {
	public static void main(String[] args) {
		int i, j;                                       	     // 定义两个循环变量
	     for (i = 1; i <= 9; i++) { 		     // 外层循环
			for (j = 1; j <= i; j++) {      	     // 内层循环
				if (i > 4) {                  // 判断i的值是否大于4
					break; 	     // 跳出外层循环
				}
				System.out.print("*"); // 打印*
			}
			System.out.print("\n");	     // 换行
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
程序运行结果如下图。

6.2 continue语句

continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。

接下来通过对1~100之内的奇数求和演示continue的用法。
```
public class Example18 {
	public static void main(String[] args) {
		int sum = 0;                                  // 定义变量sum，用于记住和
		for (int i = 1; i <= 100; i++) {
			if (i % 2 == 0) {                // i是一个偶数，不累加
				continue;           // 结束本次循环
			}
			sum += i;                        // 实现sum和i的累加
		}
		System.out.println("sum = " + sum);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
```
程序运行结果如下图。

上述代码使用for循环让变量i的值在1~100之间循环，在循环过程中，当i的值为偶数时，执行continue语句结束本次循环，进行下一次循环；当i的值为奇数时，sum和i进行累加，最终得到1~100之间所有奇数的和，打印“sum = 2500”。
相关阅读:
【轨道机器人】成功驱动伺服电机（学生电源、DCH调试软件、DH系列伺服驱动器）
Kafka中topic（主题）、broker（代理）、partition（分区）和replication（副本）它们的关系
 安卓常见设计模式12------观察者模式（Kotlin版、Livedata、Flow）
go之字符串拼接使用-＞性能-＞背后原因
 Python 基础入门指南，干货分享来啦！
Day8力扣打卡
 6. 抽象类和接口
 5.4 Go语言中自定义类型与结构体(Struct)
HackMyVm，Chapter 1: Venu 复现 01 - 24
接雨水【Leecode 42】（坐标轴上的故事)
原文地址：https://blog.csdn.net/W_chuanqi/article/details/125896986

循环次数	i	sum
第一次	1	1
第二次	2	3
第三次	3	6
第四次	4	10

文章目录

一、选择结构语句

1 if条件语句

1.1 if语句

1.2 if…else语句

1.3 if…else if…else语句

2 三元运算符

3 switch条件语句

二、循环结构语句

1 while循环语句

2 do…while循环语句

3 for循环语句

4 foreach语句

5 循环嵌套

6 循环控制语句

6.1 break语句

6.2 continue语句