【基础】java 循环语句

柔情只为你懂 2022-08-02 11:49 232阅读 0赞

## Java循环语句之 while ##

生活中，有些时候为了完成任务，需要重复的进行某些动作。如参加 10000 米长跑，需要绕 400 米的赛道反复的跑 25 圈。在 Java 中实现功能时，也经常需要重复执行某些代码，例如，我们为了表示“浓烈的爱”，希望输出 1000 行“我爱慕课网！”。显然，此时重复敲 1000 遍输出语句是不靠谱滴！！那么，有木有好的办法来解决呢？ 有，**循环语句**！

Java 常用的 3 种循环： **while 、 do...while 、 for**

本小节咱们先来聊聊 **while**

语法：

[![53699fb9000143d801590067.jpg][]][53699fb9000143d801590067.jpg]

执行过程：

< 1 >、 判断 while 后面的条件是否成立( true / false )

< 2 >、 当条件成立时，执行循环内的操作代码 ，然后重复执行< 1 >、< 2 >， 直到循环条件不成立为止

特点：**先判断，后执行**

实现功能：顺序输出 1 ～ 5 这 5 个数字。

实现思路：使用一个变量 i 代表 1 - 5 之间的数字，值从 1 开始，每次循环时输出 i 的值，并且对 i 的值加 1 ，只要 i 小于等于数字 5 就执行该循环

public static void main(String[] args) {
 
 		int i = 1; // 代表 1 - 5 之间的数字
 
 		// 当变量小于等于 5 时执行循环
 		while ( i<=5 ) {
 
 			// 输出变量的值，并且对变量加 1，以便于进行下次循环条件判断
 			System.out.println(i);
 			i++;
 		}
 	}

## Java循环语句之 do...while ##

**do...while 循环**与 while 循环语法有些类似，但执行过程差别比较大。

语法：

[![536a018100011a0401720070.jpg][]][536a018100011a0401720070.jpg]

执行过程：

<1>、 先执行一遍循环操作，然后判断循环条件是否成立

<2>、 如果条件成立，继续执行< 1 > 、< 2 >，直到循环条件不成立为止

特点： **先执行，后判断**

由此可见，do...while 语句保证循环**至少被执行一次**！

实现功能：计算 50 以内（包括 50 ）的偶数之和

实现思路：首先定义一个变量 sum ，用来保存所有偶数的和，然后定义一个变量 num 代表 1--50 之间的偶数，值从 2 开始，每次循环执行时将 num 的值累加保存在变量 sum 中，并且将 num 值加 2 (偶数嘛，你懂得哈~~)，只要 num 的值在 1--50 之内就重复执行该循环

public static void main(String[] args) {
 
 		int sum = 0; // 保存 1-50 之间偶数的和
 
 		int num = 2; // 代表 1-50 之间的偶数
 
 		do {
 			//实现累加求和
 sum+=num;
 
 			num = num + 2; // 每执行一次将数值加2，以进行下次循环条件判断
 
 		} while ((num>0)&&(num<=50)); // 满足数值在 1-50 之间时重复执行循环
 
 		System.out.println(" 50以内的偶数之和为：" + sum );
 	}

## Java循环语句之 for ##

Java 的循环结构中除了 while 和 do...while 外，还有 **for 循环**，三种循环可以相互替换。

语法：

[![536af1e60001f83604160073.jpg][]][536af1e60001f83604160073.jpg]

执行过程：

<1>、 执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次

<2>、 进行循环条件的判断，如果条件为 true ，则执行循环体内代码；如果为 false ，则直接退出循环

<3>、 执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断

<4>、 依次重新执行< 2 >、< 3 >、< 4 >，直到退出循环

特点：相比 while 和 do...while 语句**结构更加简洁易读**

需要留心的几个小细节：

1、 for 关键字后面括号中的三个表达式必须用 “;” 隔开，三个表达式都可以省略，但 “;” 不能省略。

a. 省略“循环变量初始化”，可以在 for 语句之前由赋值语句进行变量初始化操作

**b. 省略“循环条件”，可能会造成循环将一直执行下去，也就是我们常说的“死循环”现象**

在编程过程中要避免“死循环”的出现，因此，对于上面的代码可以在循环体中使用 break 强制跳出循环（关于 break 的用法会在后面介绍）。

c. 省略“循环变量变化”，可以在循环体中进行循环变量的变化，如：

2、 for 循环变量初始化和循环变量变化部分，可以是使用 “,” 同时初始化或改变多个循环变量的值，如：

[![536c8b620001eb1005560086.jpg][]][536c8b620001eb1005560086.jpg]

代码中，初始化变量部分同时对两个变量 i 和 j 赋初值，循环变量变化部分也同时对两个变量进行变化，运行结果：

[![536c8dc50001b60e00730112.jpg][]][536c8dc50001b60e00730112.jpg]

3、 循环条件部分可以使用逻辑运算符组合的表达式，表示复杂判断条件，但一定注意运算的优先级，如：

[![536c8e120001306804240071.jpg][]][536c8e120001306804240071.jpg]

代码中，必须同时满足变量 i 小于 10 ，并且 i 不等于 5 时才会进行循环，输出变量 i 的值

实现功能：计算 1 到 100 之间不能被 3 整除的数之和

实现思路：定义一个变量 sum 用来保存数据和，定义一个变量 i 代表 1--100 之间的数据，值从 1 开始。通过 for 循环判断 i 是否是 3 的倍数，符合要求的数据保存在 sum 中。

运行结果为： **1到100之间不能被3整除的数之和为：3367**

public static void main(String[] args) {
 		int sum = 0; // 保存不能被3整除的数之和
 		
 		// 循环变量 i 初始值为 1 ,每执行一次对变量加 1，只要小于等于 100 就重复执行循环
 		for (int i = 1; i<=100; i++ ) {
 			
 			// 变量 i 与 3 进行求模（取余），如果不等于 0 ，则表示不能被 3 整除
 			if (i % 3 != 0) { 
 				sum = sum + i; // 累加求和
 			}
 		}
 		
 		System.out.println("1到100之间不能被3整除的数之和为：" + sum);
 	}

## Java循环跳转语句之 break ##

生活中，我们经常会因为某些原因中断既定的任务安排。如在参加 10000 米长跑时，才跑了 500 米就由于体力不支，需要退出比赛。在 Java 中，我们可以使用 break 语句退出指定的循环，直接执行循环后面的代码。

例如，使用循环输出 1--10的数值，其中，如果数值大于 2 ，并且为 3 的倍数则停止输出。

实现代码：

[![536b36a80001ed4b05420273.jpg][]][536b36a80001ed4b05420273.jpg]

运行结果：

[![536b36d70001a8f200670071.jpg][]][536b36d70001a8f200670071.jpg]

**实现功能：**循环将 1 到 10 之间的整数相加，如果累加值大于 20，则跳出循环，并输出当前的累加值。

**实现思路：**定义一个变量 sum 保存累加值，定义一个变量 i 保存 1 至 10 之间的整数，在循环中进行累加求和，同时判断累加值是否大于 20 ，当大于 20 时输出当前的累加值并退出循环。

public static void main(String[] args) {
 		
 		// 保存累加值
 		int sum = 0;
 		
 		// 从1循环到10
 		for (int i = 1; i <= 10; i++) {
 			
 			// 每次循环时累加求和
 			sum = sum + i;
 			
 			// 判断累加值是否大于20，如果满足条件则退出循环
 			if ( sum>20 ) {
 				
 				System.out.print("当前的累加值为:" + sum);
 				
 				break;//退出循环
 				
 			}
 		}
 	}

## Java循环跳转语句之 continue ##

**continue** 的作用是跳过循环体中剩余的语句执行下一次循环。

例如，打印 1--10 之间所有的偶数，使用 continue 语句实现代码为：

[![536b50410001d1a706020200.jpg][]][536b50410001d1a706020200.jpg]

运行结果：

[![536b50770001d42a00350109.jpg][]][536b50770001d42a00350109.jpg]

**实现功能：**求 1 到 10 之间的所有偶数的和。

**实现思路：**定义一个变量 sum 保存累加值，定义一个变量 i 保存 1 到 10 之间的整数，循环遍历并进行判断，如果 i 不能被 2 整除，则结束本次循环，继续执行下一次循环，否则进行累加求和

public static void main(String[] args) {
 
 		int sum = 0; // 保存累加值
 
 		for (int i = 1; i <= 10; i++) {
 
 			// 如果i为奇数,结束本次循环，进行下一次循环
 			if ((i%2)==1 ) {
 				continue
 			}
 
 			sum = sum + i;
 		}
 
 		System.out.print("1到10之间的所有偶数的和为：" + sum);
 	}

## Java 循环语句之多重循环 ##

循环体中包含循环语句的结构称为**多重循环**。三种循环语句可以自身嵌套，也可以相互嵌套，最常见的就是**二重循环**。在二重循环中，外层循环每执行一次，内层循环要执行一圈。

如下所示：

[![549154470001ea5204920260.jpg][]][549154470001ea5204920260.jpg]

例如：使用 \* 打印长方形：

[![536c5253000181a900810058.jpg][]][536c5253000181a900810058.jpg]

实现代码为：

[![536c549d0001381003560206.jpg][]][536c549d0001381003560206.jpg]

执行流程：当 i = 1 时，外层循环条件成立，进入内层循环，开始打印第一行内容。此时， j 从 1 开始，循环 8 次，内层循环结束后换行，实现第一行 8 个 \* 的输出。接下来返回外层循环 i 变为 2 ，准备打印下一行，依此类推，直到完成长方形的打印。

**实现功能：**使用 \* 打印直角三角形

**实现思路：**上面的图形中，第 1 行有一个 \* 号，第 2 行有两个 \* 号，第 3 行有三个 \* 号，所以可以使用二重循环来实现。其中，外层循环控制行数，内层循环控制每行的 \* 号数。同时，我们发现一个规律，当打印每行信息时，内层循环变量的最大值和外层循环变量的值相等。

效果如下：

[![536c53f70001ce2200960076.jpg][]][536c53f70001ce2200960076.jpg]

public static void main(String[] args) {
 
 		System.out.println("打印直角三角形");
 
 		// 外层循环控制行数
 		for (int i = 1; i<4;i++ ) {
 
 			// 内层循环控制每行的*号数
 			// 内层循环变量的最大值和外层循环变量的值相等
 			for (int j = 1; j<=i;j++ ) {
 
 				System.out.print("*");
 			}
 
 			// 每打印完一行后进行换行
 			System.out.println();
 		}
 	}

**判断一个数（小于10位）的位数。**

**输入999，则输出 “它是个3位的数！”**

public static void main(String[] args){
 	 int num = 999;
 	 int count = 0;
 	 if(num>=0 && num<999999999){
 	 while(num!=0){
 	 count++;
 	 num/=10;
 	 }
 	 System.out.println("它是个"+count+"位的数！");
 	 }
 	 else{
 	 System.out.println("输入有误！");
 	 
 	 }
 }

[53699fb9000143d801590067.jpg]: /images/20220731/3f11b44bd4d24fc1aab1fb294a7736e1.png
[536a018100011a0401720070.jpg]: /images/20220731/acb17c714a644b46935374f02ee5ebea.png
[536af1e60001f83604160073.jpg]: /images/20220731/01e2c32f5a3c418294da287c0e471fb2.png
[536c8b620001eb1005560086.jpg]: /images/20220731/6aedf5c9466c4c319f122b1c133a110b.png
[536c8dc50001b60e00730112.jpg]: /images/20220731/7cb5926bd2df4b8da375a8720b99d8f4.png
[536c8e120001306804240071.jpg]: /images/20220731/cea5533cb4164cde8929d18a6dc44728.png
[536b36a80001ed4b05420273.jpg]: /images/20220731/594954be6c2144ed92abf6448255d40a.png
[536b36d70001a8f200670071.jpg]: /images/20220731/787dcf36910f476d944f96eb919dda86.png
[536b50410001d1a706020200.jpg]: /images/20220731/a10c1ddba7dc4c49b7fd84cf6ee4fec2.png
[536b50770001d42a00350109.jpg]: /images/20220731/a66a7bdfe35448dcb81abb372ca1bf93.png
[549154470001ea5204920260.jpg]: /images/20220731/3c116344e6ee4681b35e53e6dee0ce4b.png
[536c5253000181a900810058.jpg]: /images/20220731/122491feb9b84a37ba8e4c6546251344.png
[536c549d0001381003560206.jpg]: /images/20220731/c2602790b1974d279fd67567d90d6dcc.png
[536c53f70001ce2200960076.jpg]: /images/20220731/4219c29b50c24b908f9ff93fac170be5.png