Contents
2.3. 循环语句¶
2.3.1. while循环语句¶
- while语句也称条件判断语句。它的循环方式为利用一个条件来控制是否要继续反复执行这个语句。 语法如下：
while(条件表达式)
{
执行语句
}
当条件表达式的返回值为真时，则执行“{}”中的语句，当执行完“{}”中的语句后，重新判断条件表达式的 返回值，直到表达式返回的结果为假时，退出循环。
while循环语句的执行示例：
package Number;
public class GetSum {
public static void main(String[] args) {
int x=1;
int sum=0;
while (x<=10) {
sum = sum + x; //while循环语句，当变量满足条件表达式时执行循环体语句
x++;
}
System.out.println("sum = " + sum);
}
}
// 输出结果：
sum = 55
初学者经常犯的一个错误就是在while表达式的括号后加“；”。如
while (x==5);
System.out.println("x的值为5")
这时程序会任务要执行一条空语句，而进入无限循环，Java编译器又不会报错，这可能会浪费很多时间去调试，
需要注意这个问题。
2.3.2. do..while循环语句¶
- do..while循环语句与while循环语句类似，它们之间的区别是while语句为先判断条件是否成立再执行循环体 而do…while循环语句则先执行一次循环之后，再判断条件是否成立。
也就是说，do…while循环语句中“{}”中的程序至少要被执行一次。 语法如下：
do {
执行语句
}
while(条件表达式);
注意：
do...while语句与while语句有一个明显的区别，do...while.语句在结尾处多了一个分号(;)。
eg：
package com.company;
public class Main {
public static void main(String[] args) {
// write your code here
int a = 100;
while (a == 60) {
System.out.println("ok1 ");
a--;
}
int b = 100;
// do..while语句循环体
do {
System.out.println("ok2 "); //ok2
b--;
} while (b == 60); //指定循环结束条件
}
}
2.3.3. for循环语句¶
- for循环是Java程序设计中最有用的循环语句之一。一个for循环可以用来重复执行某条语句，直到某个 条件得到满足。java 5 之后 新增了foreach语法。
for语句¶
- 语法如下：
for (表达式1；表达式2；表达式3)
{
语句序列
}
* 表达式1,：初始化表达式，负责完成变量的初始化。
* 表达式2：循环条件表达式，值为boolean型的表达式，指定循环条件。
* 表达式3：循环后操作表达式，负责修整变量，改变循环条件。
package Number;
public class for_Test {
public static void main(String[] args) {
int sum=0; //声明变量，用于保存各数相加后的结果
for (int i=2; i<=100; i+=2) {
sum = sum + i; //指定循环条件及循环体
}
// 将相加后的结果输出
System.out.println("2到100之间的所有偶数之和为：" + sum);
}
}
//输出结果
2到100之间的所有偶数之和为：2550
技巧：
while实现无限循环
public class ch6_8 { public static void main(String[] args) { // while (true){ // System.out.println("这里是一个死循环......\n"); // } for (;;){ System.out.println("这是一个无限死循环...."); } } }
for循环实现无限循环。语法格式如下：
for (;;) {
System.out.println("loop.......");
}
// 无限循环可以通过break进行跳出
for (;;) {
// System.out.println("loop.......");
if(x<20)
break;
x++;
}
eg
打印99乘法表
package for_yuju;
public class continue_001 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i + "*" + j + "=" + (i + j) + "\t");
}
System.out.println();
}
}
}
/**
*
1*1=2
2*1=3 2*2=4
3*1=4 3*2=5 3*3=6
4*1=5 4*2=6 4*3=7 4*4=8
5*1=6 5*2=7 5*3=8 5*4=9 5*5=10
6*1=7 6*2=8 6*3=9 6*4=10 6*5=11 6*6=12
7*1=8 7*2=9 7*3=10 7*4=11 7*5=12 7*6=13 7*7=14
8*1=9 8*2=10 8*3=11 8*4=12 8*5=13 8*6=14 8*7=15 8*8=16
9*1=10 9*2=11 9*3=12 9*4=13 9*5=14 9*6=15 9*7=16 9*8=17 9*9=18
*/
2.3.4. foreach语句¶
foreach 语句是for语句的特殊简化版本，不能完全取代for语句，但任何foreach语句都可以改写为for语句版本。
foreach并不是一个关键字，习惯上将这种特殊的for语句格式称为foreach语句。
foreach语句在遍历数组等方面为程序员提供了很大的方便
语法如下：
for (元素遍历x：遍历对象obj){
引用了x的java语句；
}
eg：
package Number;
public class Repetition {
public static void main(String[] args) {
int arr[] = {7,10,1}; //声明一维数组
System.out.println("一维数组中的元素分别为： ");
for(int x:arr) {
// foreach语句，int x 引用的变量，arr指定要循环变量的数组，将x输出
System.out.println(x);
}
}
}
2.3.5. 循环控制¶
循环控制包含两方面的内容：
一方面是控制循环变量的变化方式
另一方面是控制循环的跳转
主要涉及到两个关键字：
break和continue
break是中断循环
continue是执行下一次循环
break语句¶
break语句可以跳出switch结构，在循环结构中，同样也可用break语句跳出当前循环体，
从而中断当前循环
在循环体中使用break语句有两种方式：带有标签和不带标签。语法格式如下：
break; //不带标签
break label; //带标签，label是标签名
不带标签的break语句使程序跳出所在层的循环体，而带标签的break语句使程序跳出标签指示的循环 体。
eg:
package Number;
public class BreakTest {
public static void main(String[] args) {
for (int i=0;i<=100;i++) {
System.out.println(i);
// 如果i等于6就跳出循环
if (i==6) {
break;
}
}
System.out.println("===========end===========");
}
}
//输出结果
0
1
2
3
4
5
6
===========end===========
**注意： 如果遇到循环嵌套的情况，break语句将只会使程序流程跳出包含它的最内层的循环结构， 只跳出一层循环。 eg：
public class BreakinsideNested {
public static void main(String[] args) {
for (int i=0;i<3;i++) {
for (int j=0;j<6;j++) {
// 如果j等于4就结束内部循环
if (j==4) {
break;
}
System.out.println("i=" + i + " j="+ j);
}
}
}
}
// 输出结果
i=0 j=0
i=0 j=1
i=0 j=2
i=0 j=3
i=1 j=0
i=1 j=1
i=1 j=2
i=1 j=3
i=2 j=0
i=2 j=1
i=2 j=2
i=2 j=3
从这个运行结果我们可以看出： （1）循环中的if语句判断：如果j等于4时，执行break语句，则中断了内层的循环，输出的j值最大到3为止 （2）外层的循环没有受任何影响，输出的i值最大为2，正是for循环设定的最大值。
如果要让break跳出外层循环，java提供了“标签”的功能，语法如下：
标签名：循环体{
break 标签名;
}
- 标签名：任意标识符
- 循环体：任意循环语句
- break 标签名：break跳出指定的循环体，此循环体的标签名必须与break的标签名一致 带有标签的break可以制定跳出的循环，这个循环可以是内层循环，也可以是外层循环
eg：带有标签的break跳出外层循环
public class BreakOutsideNested {
public static void main(String[] args) {
// 在for循环前用标签标记
Loop:for(int i=0; i<3; i++) {
for (int j=0; j<6; j++) {
if(j==4) {
// 如果j等于4就结束外层循环，跳出Loop标签标记的循环体
break Loop;
}
System.out.println("i=" +i + " j=" + j);
}
}
}
}
//输出结果
i=0 j=0
i=0 j=1
i=0 j=2
i=0 j=3
continue语句¶
continue语句是针对break语句的补充，contunye不是立即跳出循环体，而是跳过本次循环结束前的语句， 回到循环的条件测试部分，重新开始执行循环，在for循环语句中遇到continue后，首先执行 循环的增量部分，然后进行条件测试。在while和do…while循环中，continue语句使控制直接回到条件 测试部分。
在循环体中使用continue语句有两种方式可以带有标签，也可以不带标签。语法格式如下：
continue //不带标签
continue label //带标签，label是标签名
eg：输出1~20之间的奇数
public class continue1 {
public static void main(String[] args) {
for (int i=0;i<20;i++) {
// 如果i是偶数
if (i%2 == 0) {
continue; //跳到下一循环
}
System.out.println(i); //输出i的值
}
}
}
// 输出信息
1
3
5
7
9
11
13
15
17
19
与break语句一样，continue也支持标签功能，语法如下：
标签名：循环体{
continue 标签名；
}
- 标签名：任意标识符
- 循环体：任意循环语句
- continue标签名：continue跳出指定的循环体，此循环体的标签名必须与continue的标签名一致。
2.3.6. 总结¶
使用复合语句可以为变量定义一个有效区域。 使用if与switch语句，可以基于布尔类型的测试，将一个程序分成不同的部分
使用while、do…while循环语句和for循环语句，可以让程序的一部分重复执行，直到满足 某个终止循环的条件。
2.3.7. 课后练习¶
- 编写java程序，判断变量x是奇数还是偶数
public class checktest {
public static void main(String[] args) {
int x=49; //定义变量x的值为49
// 进行if判断奇数偶数
if(x%2==0) {
System.out.println("x 是一个偶数...");
}
else {
System.out.println("x 是一个奇数...");
}
}
}
- 编写java程序，应用for循环打印菱形
public class Test_for {
public static void main(String args[]) {
int lineCount = 17;// 输出的菱形有多少行，请赋值成奇数
int maxLineNum = (lineCount + 1) / 2;// 菱形最多一行
for (int i = 1; i <= maxLineNum; i++) {// 循环菱形数量越来越多的几行
for (int space = 1; space <= maxLineNum - i; space++) {// 输出空格，数量=最后一行-当前行数
System.out.print(" ");
}
for (int star = 1; star <= (i * 2) - 1; star++) {// 输出星号，数量=行数*2-1
System.out.print("* ");
}
System.out.println();// 换行
}
int declineCount = lineCount - maxLineNum;// 计算剩下的几行，这几行星号的数量是递减的
for (int i = 1; i <= declineCount; i++) {// 循环菱形数量越来越少的行数
for (int space = 1; space <= i; space++) {// 输出空格，数量等于当前的行数
System.out.print(" ");
}
for (int star = 1; star <= (declineCount - i + 1) * 2 - 1; star++) {// 输出星号，数量等于（总数-当前行数）*2-1
System.out.print("* ");
}
System.out.println();
}
}
}
- 编写java程序，使用while循环语句计算1+1/2!+1/3!….1/20!之和
public class Example_02 {
public static void main(String args[])
{
double sum = 0,a = 1;
int i = 1;
while(i <= 20)
{
sum = sum+a;
i = i+1;
a = a*(1.0/i);
}
System.out.println(sum);
}
}
2.3.8. 将循环应用于Scanner类的输入检查¶
import java.util.Scanner;
public class CH6_13_1 {
public static void main(String[] args) {
int x1, x2;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入2个整数，使用空格隔开");
while (!scanner.hasNextInt()) {
System.out.println("输入的第一个数据类型错误，请输入整数");
scanner.next(); // 用字符串方式读取1
}
x1 = scanner.nextInt();
while (!scanner.hasNextInt()) {
System.out.println("输入的第二个数据类型错误，请输入整数");
scanner.next(); // 用字符串方式读取1
}
x2 = scanner.nextInt();
System.out.printf("输入的第一个数是:%d\n", x1);
System.out.printf("输入的第二个数是:%d\n", x2);
System.out.printf("输入的数的总和是：%d\n", (x1 + x2));
}
}