Java流程控制语句最全汇总(下篇)
小熊coder 人气:0前文
本章是关于Java流程控制语句的最全汇总，本篇为汇总下篇。
流程是人们生活中不可或缺的一部分，它表示人们每天都在按照一定的流程做事。
比如出门搭车、上班、下班、搭车回家。这其中的步骤是有顺序的。
程序设计也需要有流程控制语句来完成用户的要求，根据用户的输入决定程序要进入什么流程，即“做什么”以及“怎么做”等。
从结构化程序设计角度出发，程序有 3 种结构：顺序结构、选择结构和循环结构。
若是在程序中没有给出特别的执行目标，系统则默认自上而下一行一行地执行该程序，这类程序的结构就称为顺序结构。
到目前为止，我们所编写的程序都属于顺序结构。
但是事物的发展往往不会遵循早就设想好的轨迹进行，因此，所设计的程序还需要能够具有在不同的条件下处理不同问题以及当需要进行一些相同的重复操作时，如何能省时省力地解决问题的能力。
在本章中，我们将对 Java 程序中的上述3种流程结构进行学习。
初学者应该对本章的每个小节进行仔细阅读、思考，这样才能达到事半功倍的效果。
Java foreach语句的用法
foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。
foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。
foreach 循环语句的语法格式如下：
for(类型 变量名:集合) {
语句块;
}其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。
每执行一次循环语句，循环变量就读取集合中的一个元素，其执行流程如图 1 所示。
图 1 foreach 循环语句的执行流程图
例 1
假设有一个数组，采用 for 语句遍历数组的方式如下：
// 声明并初始化数组
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };
System.out.println("----for----");
// for语句
for (int i = 0; i < numbers.length; i++) {
System.out.println("Count is:" + numbers[i]);
}上述第 2 行语句声明并初始化了 7 个元素数组集合，目前大家只需要知道当初始化数组时，要把相同类型的元素放到 {…} 中并且用逗号分隔（,）即可。
关于数组集合会在教程后面详细介绍，这里我们只需要大概了解就可以。
numbers.length 是获得数组的长度，length 是数组的属性，numbers[i] 是通过数组下标访问数组元素。
那么采用 for-each 循环语句遍历数组的方式如下：
// 声明并初始化int数组
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };
System.out.println("----for each----");
// for-each语句
for (int item : numbers) {
System.out.println("Count is:" + item);
}从示例中可以发现，item 不是循环变量，它保存了集合中的元素，for-each 语句将集合中的元素一一取出来，并保存到 item 中，这个过程中不需要使用循环变量，通过数组下标访问数组中的元素。
可见 for-each 语句在遍历集合的时候要简单方便得多。
例 2
String[] urls = { "http://c.biancheng.net/java", "http://c.biancheng.net/c", "http://c.biancheng.net/golang/" };
// 使用foreach循环来遍历数组元素
// 其中book将会自动迭代每个数组元素
for (String url : urls) {
System.out.println(url);
}从上面程序可以看出，使用 foreach 循环遍历数组元素时无须获得数组长度，也无须根据索引来访问数组元素。
foreach 循环和普通循环不同的是，它无须循环条件，无须循环迭代语句，这些部分都由系统来完成，foreach 循环自动迭代数组的每个元素，当每个元素都被迭代一次后，foreach 循环自动结束。
当使用 foreach 循环来迭代输出数组元素或集合元素时，通常不要对循环变量进行赋值，虽然这种赋值在语法上是允许的，但没有太大的实际意义，而且极容易引起错误。
例如下面程序。
String[] urls = { "http://c.biancheng.net/java", "http://c.biancheng.net/c", "http://c.biancheng.net/golang/" };
// 使用foreach循环来遍历数组元素，其中 book 将会自动迭代每个数组元素
for (String url : urls) {
url = "https://c.biancheng.net";
System.out.println(url);
}
System.out.println(urls[0]);运行上边程序，将看到如下结果：
https://c.biancheng.net
https://c.biancheng.net
https://c.biancheng.net/java
从上面运行结果来看，由于在 foreach 循环中对数组元素进行赋值，结果导致不能正确遍历数组元素，不能正确地取出每个数组元素的值。
而且当再次访问第一个数组元素时，发现数组元素的值依然没有改变。
不难看出，当使用 foreach 来迭代访问数组元素时，foreach 中的循环变量相当于一个临时变量，系统会把数组元素依次赋给这个临时变量，而这个临时变量并不是数组元素，它只是保存了数组元素的值。
因此，如果希望改变数组元素的值，则不能使用这种 foreach 循环。
使用 foreach 循环迭代数组元素时，并不能改变数组元素的值，因此不要对 foreach 的循环变量进行赋值。
例 3
在一个字符串数组中存储了几种编程语言，现在将这些编程语言遍历输出。
foreach 语句的实现代码如下：
public static void main(String[] args) {
String[] languages={"Java","ASP.NET","Python","C#","PHP"};
System.out.println("现在流行的编程语言有：");
// 使用 foreach 循环语句遍历数组
for(String lang:languages) {
System.out.println(lang);
}
}在循环体执行的过程中，每循环一次，会将 languages 数组中的一个元素赋值给 lang 变量，直到遍历 languages 数组中所有元素，循环终止。
该程序运行后的结果如下所示。
现在流行的编程语言有： Java ASP.NET Python C# PHP
Java return语句
return 关键字并不是专门用于结束循环的，return 语句用于终止函数的执行或退出类的方法，并把控制权返回该方法的调用者。
如果这个方法带有返回类型，return 语句就必须返回这个类型的值；如果这个方法没有返回值，可以使用没有表达式的 return 语句。
return 语句的一般语法格式如下：
return 与方法相同类型的变量;
如果一个方法使用了 return 语句并且后面跟有该方法返回类型的值，那么调用此方法后，所得到的结果为该方法返回的值。
例 1
当用户输入两个 double 类型的数值后需要计算这两个数值之和，而这两个操作数是可以变动的，但是求和的功能是不变的，这时就需要定义一个方法，只要在需要求和时调用该方法即可，该方法将计算之后的结果返回。代码如下：
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入操作数1：");
double num1 = input.nextDouble(); // 获取用户输入的操作数1
System.out.println("请输入操作数2：");
double num2 = input.nextDouble(); // 获取用户输入的操作数2
double d = sum(num1, num2);
System.out.println(num1 + "+" + num2 + "=" + d);
}
/**
* 创建sum() 方法，返回double 类型的数值
*
* @param i 操作数1
* @param j 操作数2
* @return 两个操作数之和
*/
public static double sum(double i, double j) {
double sum = i + j;
return sum;
}
}当用户输入两个 double 类型的数值后，程序调用 sum() 方法。
该方法有两个参数，分别表示用户输入的操作数 1 和操作数 2。
在调用该方法时，只需要将用户输入的两个数值传递过去即可，然后程序会执行 sum() 方法，对这两个数求和，并使用 return 语句将计算得出的结果返回。
在 main() 方法中，同样需要使用 double 类型的变量来接收 sum() 方法返回的值，即变量 d 为计算后的结果。
运行后的结果如下所示：
请输入操作数1： 500 请输入操作数2： 203 500.0+203.0=703.0 请输入操作数1： 5.66 请输入操作数2： 3.0158 5.66+3.0158=8.6758
Java break语句：跳出循环
某些时候需要在某种条件出现时强行终止循环，而不是等到循环条件为 false 时才退出循环。
此时，可以使用 break 来完成这个功能。
break 用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到 break，系统将完全结束该循环，开始执行循环之后的代码。
在 Java 中，break 语句有 3 种作用，分别是：在 switch 语句中终止一个语句序列、使用 break 语句直接强行退出循环和使用 break 语句实现 goto 的功能。
使用 break 语句直接强行退出循环（break 不带标签）
可以使用 break 语句强行退出循环，忽略循环体中的任何其他语句和循环的条件判断。
在循环中遇到 break 语句时，循环被终止，在循环后面的语句重新开始。
例 1
小明参加了一个 1000 米的长跑比赛，在 100 米的跑道上，他循环地跑着，每跑一圈，剩余路程就会减少 100 米，要跑的圈数就是循环的次数。
但是，在每跑完一圈时，教练会问他是否要坚持下去，如果回答 y，则继续跑，否则表示放弃。
使用 break 语句直接强行退出循环的示例如下：
public static void main(String[] args) {
Scanner input = new Scanner(System.in); // 定义变量存储小明的回答
String answer = ""; // 一圈100米，1000米为10圈，即为循环的次数
for (int i = 0; i < 10; i++) {
System.out.println("跑的是第" + (i + 1) + "圈");
System.out.println("还能坚持吗？"); // 获取小明的回答
answer = input.next(); // 判断小明的回答是否为y？如果不是，则放弃，跳出循环
if (!answer.equals("y")) {
System.out.println("放弃");
break;
}
// 循环之后的代码
System.out.println("加油！继续！");
}
}该程序运行后的效果如下所示：
跑的是第1圈 还能坚持吗？ y 加油！继续！ 跑的是第2圈 还能坚持吗？ y 加油！继续！ 跑的是第3圈 还能坚持吗？ n 放弃
尽管 for 循环被设计为从 0 执行到 10，但是当小明的回答不是 y 时，break 语句终止了程序的循环，继续执行循环体外的代码，输出“加油！继续！”。
break 语句能用于任何 Java 循环中，包括人们有意设置的无限循环。
在一系列嵌套循环中使用 break 语句时，它将仅仅终止最里面的循环。例如：
public static void main(String[] args) {
// 外循环，循环5次
for (int i = 0; i < 5; i++) {
System.out.print("第" + (i + 1) + "次循环：");
// 内循环，设计为循环10次
for (int j = 0; j < 10; j++) {
// 判断j是否等于3，如果是，则终止循环
if (j == 3) {
break;
}
System.out.print("内循环的第" + (j + 1) + "次循环\t");
}
System.out.println();
}
}该程序运行结果如下所示：
第1次循环：内循环的第1次循环 内循环的第2次循环 内循环的第3次循环 第2次循环：内循环的第1次循环 内循环的第2次循环 内循环的第3次循环 第3次循环：内循环的第1次循环 内循环的第2次循环 内循环的第3次循环 第4次循环：内循环的第1次循环 内循环的第2次循环 内循环的第3次循环 第5次循环：内循环的第1次循环 内循环的第2次循环 内循环的第3次循环
从程序运行结果来看，在内部循环中的 break 语句仅仅终止了所在的内部循环，外部循环没有受到任何的影响。
注意：一个循环中可以有一个以上的 break 语句，但是过多的 break 语句会破坏代码结构。
switch 循环语句中的 break 仅影响 switch 语句，不会影响循环。
例 2
编写一个 Java 程序，允许用户输入 6 门课程成绩，如果录入的成绩为负则跳出循环；如果录入 6 门合法成绩，则计算已有成绩之和。
使用 break 语句的实现代码如下：
public static void main(String[] args) {
int score; // 每门课的成绩
int sum = 0; // 成绩之和
boolean con = true; // 记录录入的成绩是否合法
Scanner input = new Scanner(System.in);
System.out.println("请输入学生的姓名：");
String name = input.next(); // 获取用户输入的姓名
for (int i = 1; i <= 6; i++) {
System.out.println("请输入第" + i + "门课程的成绩：");
score = input.nextInt();// 获取用户输入的成绩
if (score < 0) { // 判断用户输入的成绩是否为负数，如果为负数，终止循环
con = false;
break;
}
sum = sum + score; // 累加求和
}
if (con) {
System.out.println(name + "的总成绩为：" + sum);
} else {
System.out.println("抱歉，分数录入错误，请重新录入！");
}
}运行程序，当用户录入的分数低于 0 时，则输出“抱歉，分数录入错误，请重新录入！”信息，否则打印学生的总成绩。输出结果如下所示。
请输入学生的姓名： zhangpu 请输入第1门课程的成绩： 100 请输入第2门课程的成绩： 75 请输入第3门课程的成绩： -8 抱歉，分数录入错误，请重新录入！ 请输入学生的姓名： zhangpu 请输入第1门课程的成绩： 100 请输入第2门课程的成绩： 68 请输入第3门课程的成绩： 73 请输入第4门课程的成绩： 47 请输入第5门课程的成绩： 99 请输入第6门课程的成绩： 84 zhangpu的总成绩为：471
在该程序中，当录入第 3 门课的成绩时，录入的成绩为负数，判断条件“score<0”为 true，执行“con=false”，用 con 来标记录入是否有误。
接着执行 break 语句，执行完之后程序并没有继续执行条件语句后面的语句，而是直接退出 for 循环。之后执行下面的条件判断语句，判断 boolean 变量的 con 是否为 true，如果为 true，则打印总成绩；否则打印“抱歉，分数录入错误，请重新录入！”。
使用 break 语句实现 goto 的功能（break 带标签）
有时候，在嵌套很深的循环语句中会发生一些不可预料的事情。
此时可能更加希望跳到嵌套的所有循环语句之外。
通过添加一些额外的条件判断实现各层循环的检测很不方便。
幸运的是，Java 与 C++ 不同，Java 提供了一种带标签的 break 语句，用于跳出多重嵌套的循环语句。
break 语句可以实现 goto 的功能，并且 Java 定义了 break 语句的一种扩展形式来处理退出嵌套很深的循环这个问题。
通过使用扩展的 break 语句，可以终止执行一个或者几个任意代码块，这些代码块不必是一个循环或一个 switch 语句的一部分
。同时这种扩展的 break 语句带有标签，可以明确指定从何处重新开始执行。
break 除了具有 goto 退出深层循环嵌套作用外，还保留了一些程序结构化的特性。
标签 break 语句的通用格式如下：
break label;
label 是标识代码块的标签。
当执行这种形式的 break 语句时，控制权被传递出指定的代码块。
被加标签的代码块必须包围 break 语句，但是它不需要直接包围 break 的块。
也就是说，可以使用一个加标签的 break 语句来退出一系列的嵌套块，但是不能使用 break 语句将控制权传递到不包含 break 语句的代码块。
用标签（label）可以指定一个代码块，标签可以是任何合法有效的 Java 标识符，后跟一个冒号。
加上标签的代码块可以作为 break 语句的对象，使程序在加标签的块的结尾继续执行。
下面是使用带标签的break 语句的示例。
public class GotoDemo {
public static void main(String[] args) {
label: for (int i = 0; i < 10; i++) {
for (int j = 0; j < 8; j++) {
System.out.println(j);
if (j % 2 != 0) {
break label;
}
}
}
}
}以上程序的执行结果为：
0 1
这里的 label 是标签的名称，可以为 Java 语言中任意合法的标识符。
标签语句必须和循环匹配使用，使用时书写在对应的循环语句的上面，标签语句以冒号结束。
如果需要中断标签语句对应的循环，可以采用 break 后面跟标签名的方式。
如在上面代码中，当 j 为 1 时，“j%2!=0”条件表达式成立，则 label 标签所代表的最外层循环终止。
注意：通常紧跟 break 之后的标签，必须在 break 所在循环的外层循环之前定义才有意义。
在 switch 语句中终止一个语句序列
在 switch 语句中终止一个语句序列，就是在每个 case 子句块的最后添加语句“break;”，这个功能在《Java switch case》已经讲过，这里不在讲述。
Java continue语句详解
有时强迫一个循环提早反复是有用的，也就是，你可能想要继续运行循环，但是要忽略这次重复剩余的循环体的语句，所以 Java 提供了 continue 语句。
continue 语句是 break 语句的补充。
本节主要讲解 continue 语句。
与 break 语句一样， 它将中断正常的控制流程。
continue 语句将控制转移到最内层循环的首部。
continue 语句是跳过循环体中剩余的语句而强制执行下一次循环，其作用为结束本次循环，即跳过循环体中下面尚未执行的语句，接着进行下一次是否执行循环的判定。
continue 语句类似于 break 语句，但它只能出现在循环体中。
它与 break 语句的区别在于：continue 并不是中断循环语句，而是中止当前迭代的循环，进入下一次的迭代。
简单来讲，continue 是忽略循环语句的当次循环。
注意：continue 语句只能用在 while 语句、for 语句或者 foreach 语句的循环体之中，在这之外的任何地方使用它都会引起语法错误。
在循环体中使用 continue 语句有两种方式可以带有标签，也可以不带标签。语法格式如下：
continue //不带标签
continue label //带标签，label是标签名
下面看一个示例，代码如下：
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int i = 0; i < numbers.length; i++) {
if (i == 3) {
continue;
}
System.out.println("Count is: " + i);
}在上述程序代码中，当条件 i==3 的时候执行 continue 语句，continue 语句会终止本次循环，循环体中 continue 之后的语句将不再执行，接着进行下次循环，所以输出结果中没有 3。程序运行结果如下：
Count is: 0 Count is: 1 Count is: 2 Count is: 4 Count is: 5 Count is: 6 Count is: 7 Count is: 8 Count is: 9
带标签的 continue 语句示例代码如下：
public static void main(String[] args) {
label1: for (int x = 0; x < 5; x++) {
for (int y = 5; y > 0; y--) {
if (y == x) {
continue label1;
}
System.out.println(x+","+y);
}
}
System.out.println("Game Over!");
}默认情况下，continue 只会跳出最近的内循环（代码第 3 行的 for 循环），如果要跳出代码第 2 行的外循环，可以为外循环添加一个标签 label1，然后在第 5 行的 continue 语句后面指定这个标签 label1，这样当条件满足执行 continue 语句时，程序就会跳转出外循环。
程序运行结果如下：
0,5 0,4 0,3 0,2 0,1 1,5 1,4 1,3 1,2 2,5 2,4 2,3 3,5 3,4 4,5 Game Over!
由于跳过了 x == y，因此下面的内容没有输出。
1,1 2,2 3,3 4,4
Java选择结构和循环结构的总结
任何编程语言中最常见的程序结构就是顺序结构。
顺序结构就是程序从上到下逐行的执行，中间没有任何判断和跳转。
如果 main 方法的多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行
。这意味着：如果没有流程控制，Java 方法里的语句是一个顺序执行流，从上向下依次执行每条语句。
不论哪一种编程语言，都会提供两种基本的流程控制结构：分支结构和循环结构。
分支结构用于实现根据条件来选择性地执行某段代码，循环结构则用于实现根据循环条件重复执行某段代码。
Java 同样提供了这两种流程控制结构的语法，Java 提供了 if 和 switch 两种分支语句，并提供了 while、do while 和 for 三种循环语句。
一般写循环语句时，分以下三步走：
- 定义初始值
- 设置判断条件
- 初始值变化
除此之外，JDK5 还提供了一种新的循环：foreach 循环，能以更简单的方式来遍历集合、数组的元素。
Java 还提供了 break、continue 和 return 来控制程序的循环结构，作用如下：
- break：表示跳出当前层循环
- continue：表示跳出本次循环，进入下一次循环
- return：跳出当前方法的循环
当在实现某个功能语句时，如果需要通过某一个条件去判断，则用选择结构。
当实现某个功能需要通过循环去实现，则用循环结构。
当然循环和选择是可以相互嵌套的。
到此这篇关于Java流程控制语句最全汇总(下篇)的文章就介绍到这了,其他两个部分的内容(上、中篇)请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持!
加载全部内容