循环结构

最新推荐文章于 2021-04-21 19:22:25 发布
最新推荐文章于 2021-04-21 19:22:25 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： 入门日记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hdy989/article/details/114529737
版权

循环结构

循环结构是三大流程控制结构的最后一种，相比于顺序结构和分支结构，循环结构略复杂一些。

前面课程中已经说过，循环结构的特点是能够重复的执行某些代码。

一、循环结构的基本概念：

循环体：重复执行的代码称为循环体。可以是一条或者多条语句。
循环条件：循环体反复执行的判断条件。一般是关系表达式或者逻辑表达式。
循环结构的特征有2点：
  1. 重复执行某些代码。----具有循环体
  2. 有明确的开始和结束。----具有循环的初始状态、循环条件以及循环的控制语句

循环的初始状态：即循环的起始状态，简单说就是循环开始的时候什么样？

循环条件：循环体反复执行的判断条件。简单说就是判断循环是否能一直执行下去。

循环控制语句：循环执行中每次变化的内容，简单说就是控制循环是否执行下去。

二、为什么要使用循环？

  1. 需求：打印10遍"Hello World"。

  2. 代码：

    	public static void main(String[] args) {
		System.out.println("Hello World");
		System.out.println("Hello World");
		System.out.println("Hello World");
		System.out.println("Hello World");
		System.out.println("Hello World");
		System.out.println("Hello World");
		System.out.println("Hello World");
		System.out.println("Hello World");
		System.out.println("Hello World");
		System.out.println("Hello World");
	}

如果打印1000遍，打印1亿遍呢？代码怎么写？

  1. 需求：计算1+2+3+4+5的和。

  2. 代码：

    	public static void main(String[] args) {
		int sum = 0;
		sum = 1 + 2 + 3 + 4 + 5;
		System.out.println(sum);
	}

如果计算1+2+3+…+99+100的和，代码怎么写？

如果计算1+2+3+…+100000000的和，代码又该怎么写？

  1. 需求：100以内的质数有几个？分别是谁？
  2. 代码怎么写？

…

循环结构特别适合解决这种大规模计算或执行代码雷同的场景。

Java中一共提供了3种实现循环的语法，分别是：

  1. for循环
  2. while循环
  3. do…while循环

三、for循环

for循环是Java中最常用的循环。适用于知道循环次数的场景。

（1）for循环的语法格式

for(表达式1;表达式2;表达式3){
    循环体;
}

（2）for循环的执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AdxGYbn0-1615184353447)(08_循环结构/for循环.png)]

  1. 首先执行表达式1，表达式1通常写循环的初始化内容，即循环的初始状态。表达式1只会执行一次。
  2. 判断表达式2的真假。表达式2是循环的判断条件，表达式2的值为true，执行循环体，如果表达式2的值为false，则结束循环，执行循环之外的代码。
  3. 循环体执行完毕之后，执行表达式3。表达式3是循环的控制条件，这个条件可以影响循环的次数。
  4. 表达式3执行完毕之后，回到步骤2继续判断。

表达式2的结果为false时，循环会结束。

（3）for循环的示例

for循环示例1

  1. 需求：通过for循环打印10遍"Hello World"

  2. 代码：

    	public static void main(String[] args) {
		//需求：通过for循环打印10遍"Hello World"
		//分析：
		// 1.由题意可知循环次数是10次。
		// 2.循环体是  打印 Hello World
		for(int i = 0; i < 10; i++) {
			System.out.println("Hello World");
		}
	}

for循环的循环体一般来说比较容易理解，也比较容易找出来。在我们这个题中，循环体就是System.out.println(“Hello World”);

for循环的表达式1，表达式2，表达式3是配合使用的。三者共同控制循环的执行次数。表达式1用于指定初始条件，表达式2是一个boolean值，用于判断循环是否继续进行，表达式3往往是循环的增量，用于逼近判断条件。

一定要深入理解循环的执行流程，理解表达式1、表达式2、表达式3的关系，如何让3个表达式配合达到我们的目的。—打印10遍Hello World的变种写法。

断点调试

断点调试是开发中常用的调试技巧之一。

所谓的断点调试，指的是在程序的某个位置打上断点，程序在运行的过程中就会停在断点处，等待我们进行下一步的操作。

1.添加断点、移除断点

在代码行号的左侧，双击鼠标左键，即可添加上断点；再次双击鼠标左键，即可移除断点。

2.可以添加多少断点？

理论上来讲，每一行都可以添加断点。实际上我们只在关键代码处添加断点。

何为关键代码处？

1.复杂业务逻辑代码的开头位置

2.for循环的开始处

3.容易出现错误的代码处。

3.如何调试代码

Step Over：执行一行代码。
Step Into：进入代码内部（如果当前行是一个函数，会跳入到函数内部，如果只是一行普通代码，功能和step over一样）。

Step Return：与Step Into配套使用，用于跳出Step Into进入的函数。

Resume：结束当前断点，跳到下个断点位置。

4.断点调试有什么用？

断点调试就像电影的慢镜头一样，能让你看到每一步是怎么执行的。能看到每一步执行后，程序中的数据发生了什么样的变化。例如：变量值的更新。

5.断点调试总结

断点调试是开发项目必须具备的技能。

一定要学会添加、删除断点，学会看断点下各个变量的变化。

for循环示例2：

  1. 需求：打印1~100之间（含1和100）所有的整数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印1~100之间（含1和100）所有的整数。
		//分析：
		// 1.循环次数101次。
		// 2.循环体：打印一个整数（1~100之间）。
		for(int i = 1; i <= 100; i++) {
			System.out.println(i);
		}
	}

    或者

    	public static void main(String[] args) {
		//需求：打印1~100之间（含1和100）所有的整数。
		//分析：
		// 1.循环次数101次。
		// 2.循环体：打印一个整数（1~100之间）。
		for(int i = 16; i <= 115; i++) {
			System.out.println(i-15);
		}
	}

    或者

    	public static void main(String[] args) {
		//需求：打印1~100之间（含1和100）所有的整数。
		//分析：
		// 1.循环次数101次。
		// 2.循环体：打印一个整数（1~100之间）。
		for(int i = 100; i >= 1; i--) {
			System.out.println(101 - i);
		}
	}

通过上述的案例，你会发现同样的需求，可以使用不同的方法来实现。

在这个案例中，你要学会表达式1、表达式2、表达式3如何配合使用。—本质上是控制循环次数。

for循环示例3：

  1. 需求：打印出来100以内所有的奇数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印出来100以内所有的奇数。
		//分析：
		// 1.循环次数101次。
		// 2.循环体：打印一个奇数。---需要判断当前数是不是奇数，是就打印，不是就不打印。
		for(int i = 0; i <= 100; i++) {
			if(i % 2 == 1) {
				System.out.println(i);
			}	
		}
	}

虽然打印的是奇数，但是循环的次数是101次。只不过对于每个数做了一次判断，是奇数才打印。整体的循环次数并没有减少。

或者

 public static void main(String[] args) {
 	//需求：打印出来100以内所有的奇数。
 	//分析：
 	// 1.循环次数50次。
 	// 2.循环体：打印一个奇数。---起始值设置为1，增量设置为2。
 	for(int i = 1; i < 100; i += 2) {
 		System.out.println(i);
 	}
 }

通过这个案例你会发现：表达式1，表达式2，表达式3是配合使用的，为的是控制循环次数。

如何打印100以内所有的偶数？

for循环示例4：

  1. 需求：求1+2+3+…+9+10的和。

  2. 代码：

    	public static void main(String[] args) {
		//需求：求1+2+3+...+9+10的和。
		//分析：
		// 1.要有一个变量保存和。假定是sum
		// 2.循环次数11次。
		// 3.循环体：把数加到sum中去。
		int sum = 0;
		for(int i = 1; i <= 10; i++) {
			sum += i;
		}
		System.out.println(sum);
	}

打印1~100的和怎么写？

打印1~1000000的和怎么写？

for循环示例5：

  1. 需求：求100以内所有奇数的和。

  2. 代码：

    	public static void main(String[] args) {
		//需求：求100以内所有奇数的和。
		int sum = 0;
		for(int i = 1; i < 100; i++) {
			if(i % 2 == 1) {
				sum += i;
			}
		}
		System.out.println(sum);
	}

或者

	public static void main(String[] args) {
		//需求：求100以内所有奇数的和。
		int sum = 0;
		for(int i = 1; i < 100; i+=2) {
			sum += i;
		}
		System.out.println(sum);
	}

求100以内偶数的和怎么写？

for循环示例6：

  1. 需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。
	//判断从 100到999哪个是水仙花数，所以循环从100到999。
		//找出数字的 个位、十位、百位分别是什么，再判断立方和是不是等于原数。
		for(int i = 100; i < 1000; i++) {
			int gw = i % 10;
			int sw = i / 10 % 10;
			int bw = i / 100;
			if(gw * gw * gw + sw * sw * sw + bw * bw * bw == i) {
				System.out.println(i);
			}
		}
	}
for循环示例7：

  1. 需求：统计水仙花一共有多少个。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：统计水仙花一共有多少个。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。
		//定义一个变量count记录水仙花的个数。判断从 100到999哪个是水仙花数，所以循环从100到999。
		//找出数字的 个位、十位、百位分别是什么，再判断立方和是不是等于原数。
		//一旦某个数是水仙花数，就让count++.
		int count = 0;
		for(int i = 100; i < 1000; i++) {
			int gw = i % 10;
			int sw = i / 10 % 10;
			int bw = i / 100;
			if(gw * gw * gw + sw * sw * sw + bw * bw * bw == i) {
				System.out.println(i);
				count++;
			}
		}
		System.out.println("一共有" + count + "个水仙花数。");
	}
for循环示例8：

  1. 需求：数7游戏。从1到100（不含100），如果数是7的倍数或者包含7输出“过”，否则输出数字本身。

  2. 代码：

    	public static void main(String[] args) {
		//需求：数7游戏。从1到100（不含100），如果数是7的倍数或者包含7输出“过”，否则输出数字本身。
		for(int i = 1; i < 100; i++) {
			if(i % 7 == 0 || (i % 10 == 7 || i / 10 == 7)) {
				System.out.print("过 ");
			}else {
				System.out.print(i + " ");
			}
		}
	}
随机数

在Java中使用Random类来产生随机数。具体使用步骤如下：

  1. 导包。----import java.util.Random;//快捷键：Ctrl + Shift + O
  2. 创建Random对象。Random random = new Random();
  3. 获取随机数。int num = random.nextInt(10);-----[0,10)
随机数案例：

  1. 需求：产生1个取值范围在[0,50)的随机数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：产生1个取值范围在[0,50)的随机数。
		Random random = new Random();
		int num = random.nextInt(50);
		System.out.println(num);
	}

  3. 需求：产生1个取值范围在[5,18)的随机数。

  4. 代码：

    	public static void main(String[] args) {
		//需求：产生1个取值范围在[5,18)的随机数。
		//思路：
		//1.产生一个[0,13)的随机数
		//2.在上述记过的基础上+5
		Random random = new Random();
		int num = random.nextInt(13) + 5;
		System.out.println(num);
	}

  5. 需求：产生1个取值范围在[23,41]的随机数。

  6. 代码：

    	public static void main(String[] args) {
		//需求：产生1个取值范围在[23,41]的随机数。
		//思路：
		//1.产生一个[0,19)的随机数
		//2.在上述记过的基础上+23
		Random random = new Random();
		int num = random.nextInt(19) + 23;
		System.out.println(num);
	}

随机数的规律：要想产生一个[min, max]之间的随机数。

int num = random.nextInt(max - min + 1) + min;

for循环案例9：

  1. 需求：产生5个[10, 80]之间的随机数，并输出产生的数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：产生5个[10, 80]之间的随机数，并输出产生的数。
		//思路：循环5次，每次产生一个随机数并打印随机数。
		//先创建Random对象
		Random random = new Random();
		for(int i = 0; i < 5; i++) {
			int num = random.nextInt(80 - 10 + 1) + 10;
			System.out.print(num + " ");
		}
	}
for循环案例10：

  1. 需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数。
		//思路：
		//1.定义一个变量max保存最大的数。
		//2.循环5次，每次产生一个随机数并打印随机数。
		//3.在每次循环中，判断随机产生的数和max谁大，如果随机产生的数大，把max的值更新为随机产生的数。
		//先创建Random对象
		Random random = new Random();
		//定义一个变量保存最大的数
		int max = 0;
		for(int i = 0; i < 5; i++) {
			int num = random.nextInt(80 - 10 + 1) + 10;
			System.out.print(num + " ");
			if(num > max) {
				max = num;
			}
		}
		System.out.println("max = " + max);
	}
for循环案例11：

  1. 需求：随机产生5个[10, 80]之间的随机数，输出产生的数，并求出最小的数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：随机产生5个[10, 80]之间的随机数，输出产生的数，并求出最小的数。
		//思路：
		//1.定义一个变量min保存最小的数。
		//2.循环5次，每次产生一个随机数并打印随机数。
		//3.在每次循环中，判断随机产生的数和min谁小，如果随机产生的数小，把min的值更新为随机产生的数。
		//先创建Random对象
		Random random = new Random();
		//定义一个变量保存最小的数
		int min = 80;
		for(int i = 0; i < 5; i++) {
			int num = random.nextInt(80 - 10 + 1) + 10;
			System.out.print(num + " ");
			if(num < min) {
				min = num;
			}
		}
		System.out.println("min = " + min);
	}
for循环案例12：

  1. 需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数以及最大随机数的下标（即：第几个数最大，假定下标从0开始）。

  2. 代码：

    	public static void main(String[] args) {
		//需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数以及最大随机数的下标（即：第几个数最大，假定下标从0开始）。
		//思路：
		//1.定义一个变量max保存最大的数。
		//2.定义一个变量index保存最大随机数的下标。
		//3.循环5次，每次产生一个随机数并打印随机数。
		//4.在每次循环中，判断随机产生的数和max谁大，如果随机产生的数大，把max的值更新为随机产生的数，同时更新index的值。
		//先创建Random对象
		Random random = new Random();
		//定义一个变量保存最大的数
		int max = 0;
		//定义一个变量保存最大数的下标
		int index = 0;
		for(int i = 0; i < 5; i++) {
			int num = random.nextInt(80 - 10 + 1) + 10;
			System.out.print(num + " ");
			if(num > max) {
				max = num;
				index = i;
			}
		}
		System.out.println("max = " + max + ", index = " + index);
	}
for循环案例13：

  1. 需求：产生5个[10,20]之间的随机数，输出产生的数，并计算随机数的和以及平均值。

  2. 代码：

    	public static void main(String[] args) {
		//需求：产生5个[10, 20]之间的随机数，输出产生的数，并计算随机数的和以及平均值。
		//思路：
		//1.定义一个变量sum保存随机数的和。
		//2.定义一个变量avg保存随机数的平均数。
		//3.循环5次，每次产生一个随机数并打印随机数，将随机数的值加到sum中。
		//4.通过sum求avg
		//先创建Random对象
		Random random = new Random();
		//定义一个变量保存随机数的和。
		int sum = 0;
		//定义一个变量保存随机数的平均值。
		double avg = 0;
		for(int i = 0; i < 5; i++) {
			int num = random.nextInt(20 - 10 + 1) + 10;
			System.out.print(num + " ");
			sum += num;
		}
		avg = 1.0 * sum / 5;
		System.out.println("sum = " + sum + ", avg = " + avg);
	}

（4）for循环总结

for循环是最常用的循环，开发中几乎90%左右的循环都是for循环，for使用场景是明确知道循环次数的情形。

四、while循环

while是Java中第二常用的循环。while循环能实现for循环全部的功能，即：while循环可以替代for循环。除此以外，while循环还适用于不知道具体循环次数的循环（只知道循环结束条件，但不清楚循环多少次结束。）。

while循环最大的特点：适用于不知道循环次数的循环。

在开发中，如果知道循环次数，往往使用for循环（因为for循环的格式比较简洁，书写比较方便），只有不知道循环次数的时候，才使用while循环。

（1）while循环的语法格式

while(条件表达式){
    语句体;
}

（2）while循环的执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OkCVPCsn-1615184353454)(08_循环结构/while循环.gif)]

  1. 计算条件表达式的值。
  2. 如果条件表达式的值为true，执行循环体。
  3. 执行完循环体以后，回到步骤1。
  4. 如果条件表达式的值为false，结束循环的执行。

（3）while循环的示例

一、while循环替代for循环
while循环示例1：

  1. 需求：通过while循环打印10遍"Hello World"

  2. 代码：

    	public static void main(String[] args) {
		//需求：通过while循环打印10遍"Hello World"
		//分析：
		//1.循环体是 打印"Hello World"
		//2.循环结束的条件是打印10遍"Hello World"
		//---因此需要有一个计数器(变量)，帮我们记录打印了几次（每打印一次，count就自增1）
		//---循环执行的条件：计数器不够十次。
		int count = 0;
		while(count < 10) {
			System.out.println("Hello World");
			count++;//每打印一次，count就自增1
		}
	}
while循环示例2：

  1. 需求：打印1~100之间（含1和100）所有的整数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印1~100之间（含1和100）所有的整数。
		//分析：
		//1.循环体是打印整数
		//2.循环结束的条件是打印完1~100之间所有的整数。
		//---因此，需要有一个变量来表示当前正在打印的整数，当前数打印完之后要换下一个数。
		//---循环条件：当前打印的整数没有超出[1, 100]范围
		int num = 1;
		while(num <= 100) {
			System.out.println(num);//打印当前的数
			num++;//换下一个数
		}
	}
while循环示例3：

  1. 需求：打印出来100以内所有的偶数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印出来100以内所有的偶数。
		//分析：
		//1.循环体：打印偶数
		//2.循环结束条件是打印完100以内所有的偶数。
		//---因此，需要有一个数表示当前数字（可能是偶数，可能是奇数）。判断数字的奇偶，如果是偶数就打印，如果是奇数不做任何处理。无论这个数字是否是偶数，判断完之后要换下一个数字。
		//---循环执行条件：尚未检查完100以内所有的数字
		int num = 0;
		while(num <= 100) {
			if(num % 2 == 0) {
				System.out.println(num + " ");
			}
			num++;
		}
	}
while循环示例4：

  1. 需求：求100以内所有奇数的和。

  2. 代码：

    	public static void main(String[] args) {
		//需求：求100以内所有奇数的和。
		//分析：
		//1.循环体：把奇数加到sum中去。---定义一个表示和的变量sum，在循环体中把奇数加到sum中去
		//2.循环结束的条件：100以内的数字全判断完毕。
		//---因此，需要有一个数表示当前数字。对这个数字判断奇偶，如果是奇数，加到sum中去，如果是偶数，不做处理。判断完毕之后，无论奇偶都要换下一个数字。
		//---循环执行的条件，100以内的数据尚未检查完毕。
		int sum = 0;
		int num = 0;
		while(num < 100) {
			if(num % 2 == 1) {
				sum += num;
			}
			num++;
		}
		System.out.println(sum);
	}
while循环示例5：

  1. 需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。
		//分析：
		//1.循环体：判断数字是不是数显花数
		//2.循环结束条件：100~1000（不含1000）之间，所有的数都判断了一遍。
		//---因此，需要定义一个变量表示当前数字。判断这个数字是不是水仙花数，是的话打印这个数。判断完后，无论是否是水仙花数，都要换下一个数。
		//---循环执行的条件，100~1000之间的数尚未判断完毕。
		int num = 100;
		while(num < 1000) {
			int gw = num % 10;
			int sw = num / 10 % 10;
			int bw = num / 100;
			if(gw * gw * gw + sw * sw * sw + bw * bw * bw == num) {
				System.out.print(num + " ");
			}
			num++;
		}
	}
while循环示例6：

  1. 需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数。
		//分析：
		//1.定义一个变量max保存最大的随机数。
		//2.定义一个变量count记录随机数的个数。
		//3.循环体：产生随机数，输出随机数，判断随机数和max的大小，如果随机数大，把max更新为随机数的值，coun自增1
		//4.循环执行的条件：尚未产生5个随机数
		int count = 0;
		int max = 0;
		Random random = new Random();
		while(count < 5) {
			int num = random.nextInt(80 - 10 + 1) + 10;
			System.out.print(num + " ");
			if(num > max) {
				max = num;
			}
			count++;
		}
		System.out.println("max = " + max);
	}
while循环替代for循环总结

通过上述种种示例，不难发现while确实可以替代for循环。而且可以发现for循环中的表达式1，表达式2，表达式3以及循环体，在while循环中都有出现。

for循环的表达式1对应的是while循环之前的循环初始条件。

for循环的表达式2对应的是while循环的条件表达式。

for循环的表达式3对应的是while循环中的 变量自增。

for循环的循环体对应的是while循环中除了变量自增之外的全部内容。

while循环的完整语法格式是：

循环的初始条件;//对应for循环的 表达式1
while(条件表达式){//对应for循环的 表达式2
    循环体;//对应for循环的 循环体
    循环增量;//对应for循环的表达式3
}
开发中，如果知道循环次数，一般使用for循环，不使用while循环。–因为for简单。
二、while循环自身特长：不知道循环次数
while循环示例1：

  1. 需求：限定用户输入内容。提示用户输入17（含1和7）之间的数字。如果用户输入的数字范围不在17之内，让用户重新输入，直到用户输入的数字符合要求。

  2. 代码：

    	public static void main(String[] args) {
		//需求：限定用户输入内容。提示用户输入1~7（含1和7）之间的数字。
		//如果用户输入的数字范围不在1~7之内，让用户重新输入，直到用户输入的数字符合要求。
		int num = 0;
		Scanner scanner = new Scanner(System.in);
		while(num > 7 || num < 1) {
			System.out.print("请输入1~7(含1和7)之间的数字:");
			num = scanner.nextInt();
		}
		System.out.println("您输入的数字是：" + num);
	}
while循环示例2：

  1. 需求：输入一个整数，判断是几位数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：输入一个整数，判断是几位数。
		//分析：
		//1.对于一个数而言，除以10，相当于抹掉了1位（个位）。再除以10，相当于又抹掉了一位。也就是说判断一个数是几位数，就看能除以10几次（除后商不为0）
		//2.循环体：将整数更新为除以10以后的数。计数器自增1.
		//3.循环执行的条件：整数不为0。
		int count = 0;
		Scanner scanner = new Scanner(System.in);
		System.out.print("请输入一个整数：");
		int num = scanner.nextInt();
		while(num != 0) {
			num = num / 10;
			count++;
		}
		System.out.println("你输入的是一个" + count + "位数！");
	}
while循环示例3：

  1. 需求：世界上最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如有一张足够大的纸，它的厚度是0.1毫米。请问折叠多少次，可以折成珠穆朗玛峰的高度？

  2. 代码：

    	public static void main(String[] args) {
		//需求：世界上最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如有一张足够大的纸，它的厚度是0.1毫米。
		//请问折叠多少次，可以折成珠穆朗玛峰的高度？
		//分析：
		//1.纸每折叠一次，都是上一次厚度的2倍。
		//2.循环体：更新当前厚度，更新折叠次数。
		//3.循环执行条件：厚度小于珠穆朗玛峰的高度。
		double thickness = 0.1;
		int count = 0;
		while(thickness <= 8844430) {
			thickness *= 2;
			count++;
		}
		System.out.println("达到珠穆朗玛峰的高度，需要折叠" + count + "次，此时纸的厚度是" + thickness + "毫米");
	}
while循环示例4：

  1. 需求：生成2个[10, 20]之间的随机数，如果生成的2个数不相等，再重新生成，直到2个数相等。

  2. 代码：

    	public static void main(String[] args) {
		//需求：生成2个[10, 20]之间的随机数，如果生成的2个数不相等，再重新生成，直到2个数相等。
		Random random = new Random();
		int num1 = random.nextInt(20 - 10 + 1) + 10;
		int num2 = random.nextInt(20 - 10 + 1) + 10;
		System.out.println("num1 = " + num1 + ", num2 = " + num2);
		while(num1 != num2) {
			num1 = random.nextInt(20 - 10 + 1) + 10;
			num2 = random.nextInt(20 - 10 + 1) + 10;
			System.out.println("num1 = " + num1 + ", num2 = " + num2);
		}
	}
while循环示例5：

  1. 需求：如果你是一个富二代，你有10亿元（1000000000），每天花一半，多天可以花完。

  2. 代码：

    	public static void main(String[] args) {
		// 需求：如果你是一个富二代，你有10亿元（1000000000），每天花一半，多天可以花完。
		int money = 1000000000;
		int day = 0;
		while (money != 0) {
			money /= 2;
			day++;
		}
		System.out.println("10亿元可以花" + day + "天！");
	}
while循环总结—不知道循环次数

while循环最大的用途就是处理不知道循环次数的循环，这一点是for无法做到的。在开发中，凡是用到while的地方，都是因为需要循环，但不知道具体要循环几次。

（4）while总结

  1. while可以实现for循环的全部功能
  2. while循环善于处理不知道循环次数的循环。
  3. 开发中使用的是while的第二种功能。

五、do…while循环

do…while是Java中第三种循环结构，是使用频率最低的循环结构。do…while循环能实现while循环全部的功能，do…while循环和while循环的唯一区别是，do…while循环会至少执行一次循环。

（1）do…while循环的语法格式

do{
    循环体;
}while(表达式);

注意：上述格式中，while(表达式)后面有一个分号。

（2）do…while循环的执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kclg5j4m-1615184353468)(08_循环结构/do…while.jpg)]

  1. 执行循环体语句。
  2. 判断表达式的值是否为true。如果为true，执行步骤1。
  3. 如果表达式的值为false，结束循环。

while循环是先判断条件在决定是否执行循环体

do…while是先执行循环体再判断条件。即：至少执行一次循环体。

（3）do…while循环的示例

do…while循环示例1：

  1. 需求：打印1~100之间（含1和100）所有的整数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印1~100之间（含1和100）所有的整数。
		//分析：
		//1.循环体：打印一个整数。
		//2.循环次数：100次。
		//3.起始条件：从数字1开始
		//4.循环控制：数字增1
		//4.循环条件：数字小于等于100
		int i = 1;
		do {
			System.out.println(i);
			i++;
		}while(i <= 100);
	}
do…while循环示例2：

  1. 需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。
		//分析：
		//1.循环的起始状态：从数字100开始
		//2.循环控制：数字每次加1
		//3.循环执行条件：数字小于1000
		//4.循环体：判断数字是不是水仙花数。
		int num = 100;
		do {
			int gw = num % 10;
			int sw = num / 10 % 10;
			int bw = num / 100;
			if(gw * gw * gw + sw * sw * sw + bw * bw * bw == num) {
				System.out.println(num);
			}
			num++;
		}while(num < 1000);
	}
do…while循环示例3：

  1. 需求：输入一个整数，判断是几位数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：输入一个整数，判断是几位数。
		//分析：
		//1.定义变量接收输入的整数
		//2.创建Scanner对象
		//3.提示用户输入
		//4.接收用户输入的数据
		//5.定义一个计数器，记录位数
		//5.判断数字的位数
		//  循环体：1.让数字位数减少1位，（数字 /= 10）  2.计数器加1
		//  循环执行条件：数字不等于0
		int num = 0;
		Scanner scanner = new Scanner(System.in);
		System.out.print("请输入一个整数：");
		num = scanner.nextInt();
		int count = 0;
		do {
			num /= 10;
			count++;
		}while(num != 0);
		System.out.println("您输入了一个" + count + "位数。");
	}
do…while示例4：

  1. 需求：生成2个[10, 20]之间的随机数，如果生成的2个数不相等，再重新生成，直到2个数相等。

  2. 代码：

    //需求：生成2个[10, 20]之间的随机数，如果生成的2个数不相等，再重新生成，直到2个数相等。
		Random random = new Random();
		int num1 = 0;
		int num2 = 0;
		do {
			num1 = random.nextInt(20 - 10 + 1) + 10;
			num2 = random.nextInt(20 - 10 + 1) + 10;
			System.out.println(num1 + "   " + num2);
		}while(num1 != num2);
		System.out.println("两个数相等了。这两个数是：" + num1 + "  " + num2);

（4）do…while总结

do…while本质上和while差不多，既能胜任知道循环次数的情形，也能胜任不知道循环次数的情形。与while的不同点是先执行循环体，再判断条件是否成立。

开发中do…while的使用频率比较低。因为while循环可以替代do…while，只需要在while循环之前，先把循环体的代码写一遍即可。

六、for、while、do…while区别

	public static void main(String[] args) {
		for(int i = 5; i < 5; i++) {
			System.out.println("for循环");
		}
		
		int j = 5;
		while(j < 5) {
			System.out.println("while循环");
			j++;
		}
		
		int k = 5;
		do {
			System.out.println("do..while循环");
			k++;
		}while(k < 5);
	}

上述代码执行完毕后，会打印什么结果？

do…while至少执行一次循环体。

	public static void main(String[] args) {
		for(int i = 1; i < 3; i++) {
			System.out.println(i);
		}
		//System.out.println(i);
		
		System.out.println("---华丽的分割线---");
		
		int j = 1; 
		while(j < 3) {
			System.out.println(j);
			j++;
		}
		System.out.println(j);
		System.out.println("---华丽的分割线---");
		
		int k = 1;
		do {
			System.out.println(k);
			k++;
		}while(k < 3);
		System.out.println(k);
	}

for循环中定义的变量i，只能在for循环里用，出了for循环就不能使用了。

对于while循环的 j 以及do…while循环的k来说，他们定义在了循环的外面，因此可以在循环结束后使用。

七、死循环

死循环，即无限循环。循环一旦开始就永远不会停止。在开发过程中，应当避免死循环。

（1）死循环示例：

死循环示例-for循环

代码：

	public static void main(String[] args) {
		for( ; ; ) {
			System.out.println("hello world");
		}
		System.out.println("end");//这行代码永远执行不到
	}

上面的示例，没有任何语句控制循环的结束。所以会无限打印hello world，导致循环后面的代码永远执行不到。

注意：如果程序中出现死循环，Eclipse会报错，不允许你执行。

代码：

	public static void main(String[] args) {
		for(int i = 0 ; i != 10 ; i += 3 ) {
			System.out.println("hello world");
		}
		System.out.println("end");//这行代码永远执行不到
	}

上面的示例，虽然表达式完整，但是 i != 10会永远为真，因此也是一个死循环。导致for循环后面的代码无法执行

死循环示例-while

代码：

	public static void main(String[] args) {
		int i = 0;
		while(i < 100) {
			System.out.println(i);
		}
		System.out.println("end");
	}

上面的示例，也是一个死循环，i 初始值是0，在循环体里没有任何操作去改变 i 的值，因此 i < 100永远为真，循环会无限执行，while循环后面的代码永远不会被执行到。很多新手，在写while循环的时候容易漏写i++。

正数因为这个原因，通常使用for循环不使用while循环。

代码：

	public static void main(String[] args) {
		while(true) {
			System.out.println("hello world");
		}
	}

这也是一个死循环。循环条件永远是true。

死循环示例-do…while

代码：

	public static void main(String[] args) {
		int i = 0;
		do {
			System.out.println(i);
		}while(i < 100);
		System.out.println("end");
	}

上面的示例，和while死循环的案例一样，也是因为 缺少 i++。

	public static void main(String[] args) {
		do {
			System.out.println("hello world");
		}while(true);
	}

这也是一个死循环。循环条件永远是true。

（2）如何避免死循环

  1. 对于知道循环次数的情形，使用for循环。----for循环的语法格式，表达式3处写循环控制语句，不容易忘记。while和do…while容易忘记。
  2. 写完代码以后，找临界值试试验证代码的正确性。
  3. 借助break结束循环。

八、break、continue关键字

（1）结束循环

结束循环的方式一共有2种：

  1. 循环正常结束，即循环条件不再满足时，循环正常结束。
  2. 强行结束循环，即break关键字。

在开发中无论是循环的正常结束还是通过break让循环结束，都是非常非常常见的。

（2）break关键字

break关键字一共2个用途：

  1. 用在switch…case语句中的每个case里，用于结束switch语句。
  2. 用在循环结构的循环体中，用于结束当前循环的执行。—即：break写在哪个循环里，就结束哪个循环。

如果break出现在循环体里，break用于结束当前循环。

如果循环体内，break后面还有别的代码，break后面的代码不会执行。----仅限循环体内的代码。循环体外的代码可以正常执行。

如果循环次数尚未用完，执行到了循环体中的break语句，也是直接结束循环，未执行的循环次数不再执行。

break可以出现在for循环里，可以出现在while循环里，也可以出现在do…while循环里。

break示例1：

  1. 需求：产生10个[10, 20]之间的随机数，产生随机数的过程中，如果某个随机数的值是16，结束循环。

  2. 代码：

    	public static void main(String[] args) {
		//需求：产生10个[10, 20]之间的随机数，产生随机数的过程中，如果某个随机数的值是16，结束循环。
		Random random = new Random();
		for(int i = 0; i < 10; i++) {
			int num = random.nextInt(20 - 10 + 1) + 10;
			System.out.print(num + " ");
			if(num == 16) {
				break;
			}
		}
	}
break示例2：

  1. 需求：用户可以在控制台输入任意字符串，当用户输出字符串是"exit"的时候，认为是结束输出，用户将不能再输入任何内容。

  2. 代码：

    	public static void main(String[] args) {
		//需求：用户可以在控制台输入任意字符串，当用户输出字符串是"exit"的时候，认为是结束输出，用户将不能再输入任何内容。
		System.out.println("请随意输入内容，想结束的时候输出exit并按回车。");
		Scanner scanner = new Scanner(System.in);
		while(true) {
			//获取用户输入的内容
			String str = scanner.nextLine();
			if(str.equals("exit")) {
				break;
			}
		}
	}
break示例3：

  1. 需求：猜数字。产生1个[10, 30]的随机数，从键盘上输入你的猜测结果，如果猜测的数比随机数大，提示"你猜的数据大了"，如果猜测的数比随机数小，提示"你猜测的数据小了"，如果猜测的数和随机数一样大，提示"恭喜你猜对了"，计算出猜了几次才猜对。

  2. 代码：

    	public static void main(String[] args) {
		//需求：猜数字。产生1个[10, 30]的随机数，从键盘上输入你的猜测结果，
		//如果猜测的数比随机数大，提示"你猜的数据大了"，如果猜测的数比随机数小，提示"你猜测的数据小了"，
		//如果猜测的数和随机数一样大，提示"恭喜你猜对了"，并计算出猜了几次才猜对。
		
		//生成一个[10, 30]的随机数。
		Random random = new Random();
		int num = random.nextInt(30 - 10 + 1) + 10;
		//定义变量，记录猜测的次数。
		int count = 0;
		//创建Scanner对象
		Scanner scanner = new Scanner(System.in);
		//开始猜测
		while(true) {
			System.out.print("请输入猜测的数字：");
			int yourAnswer = scanner.nextInt();
			count++;//每次1次，计数器加1。
			if(yourAnswer > num) {
				System.out.println("你猜测的数据大了。");
			}else if(yourAnswer < num) {
				System.out.println("你猜测的数据小了。");
			}else {
				System.out.println("恭喜你猜对了。" + "随机产生的数是：" + num + ", 你猜了" + count + "次猜对了！");
				break;
			}
		}
	}
break示例4：

  1. 需求：限定用户输入内容。提示用户输入17之间（含1和7）的数字。如果用户输入的不是17之间的数字，让用户继续输入，如果输入是1~7之间的数，则结束循环。

  2. 代码：

    	public static void main(String[] args) {
		//需求：限定用户输入内容。提示用户输入1~7之间（含1和7）的数字。
		//如果用户输入的不是1~7之间的数字，让用户继续输入，如果输入是1~7之间的数，则结束循环。
		Scanner scanner = new Scanner(System.in);
		while(true) {
			System.out.print("请输入1~7之间的数字：");
			int num = scanner.nextInt();
			if(num >= 1 && num <= 7) {
				break;
			}else {
				System.out.println("输入的数据有误！");
			}
		}
	}

break的使用场景举例：

  1. 从数组中查找某个数据，一旦找到，就结束循环。—数组是后面要学习的内容。
  2. 用在死循环里，用于结束死循环（通常是达到了某个条件）。
  3. 游戏里，将游戏中的怪物随机刷新在游戏地图里，如果怪物被刷新到了障碍物里（例如：河、山、树等），重新随机怪物的位置。

break关键字通常情况下和if语句搭配使用。

（3）continue关键字

continue关键字的作用是用于结束本次循环。例如：循环体里一共有10行代码，第5行出现了continue，当执行完continue以后，本次循环中第6行到第10行代码将不再执行。

continue只是结束本次循环，而不是结束整个循环。continue通常情况下也是与if语句搭配使用。

continue示例1：

  1. 需求：打印100以内所有的奇数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印100以内所有的奇数。
		for(int i = 1; i < 100; i++) {
			if(i % 2 == 0) {
				continue;
			}
			System.out.println(i);
		}
	}
continue示例2：

  1. 需求：打印100以内的整数，遇到7的倍数或者含7的数字跳过。

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印100以内的整数，遇到7的倍数或者含7的数字跳过。
		for(int i = 1; i < 100; i++) {
			if(i % 7 == 0 || (i % 10 == 7 || i / 10 == 7)) {
				continue;
			}
			System.out.print(i + " ");
		}
	}

（4）break、continue总结

  1. break用于结束当前循环。
  2. continue用于结束本次循环。
  3. break、contine通常是与if语句连用。即某种条件满足时才break或continue。
  4. break使用比较频繁，经常用在死循环里结束循环。或者用在for循环里提前结束循环。
  5. continue很少使用。

九、循环嵌套

循环嵌套：一个循环作为另外一个循环的循环体或者是循环体的一部分。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KNMZEVzV-1615184353493)(08_循环结构/循环嵌套.jpg)]

for、while、do…while可以相互嵌套。

循环嵌套示例1：

  1. 需求：打印如下内容：

    1 2 3 4 5

    1 2 3 4 5

    1 2 3 4 5

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印如下内容：
	    // 1 2 3 4 5
        // 1 2 3 4 5
        // 1 2 3 4 5
		//方法一：
		System.out.println("1 2 3 4 5 ");
		System.out.println("1 2 3 4 5 ");
		System.out.println("1 2 3 4 5 ");
		
		System.out.println("-----华丽的分割线-----");
		
		//方法二：
		for(int j = 1; j <= 5; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		
		for(int j = 1; j <= 5; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		
		for(int j = 1; j <= 5; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		
		System.out.println("-----华丽的分割线-----");
		
		//方法三：
		for(int i = 0; i < 3; i++) {
			System.out.println("1 2 3 4 5 ");
		}
		
		System.out.println("-----华丽的分割线-----");
		
		//方法四：
		for(int i = 0; i < 3; i++) {
			for(int j = 1; j <= 5; j++) {
				System.out.print(j + " ");
			}
			System.out.println();
		}
	}

上述案例方法四中：一个循环就作为了另外一个循环体的内容，这就是循环嵌套。外层循环执行1次，内存循环要执行1遍。

循环嵌套示例2：

  1. 需求：打印如下内容：

    1

    1 2

    1 2 3

    1 2 3 4

    1 2 3 4 5

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印如下内容：
//		1 
//		1 2 
//		1 2 3 
//		1 2 3 4 
//		1 2 3 4 5 
		/*
		 * 分析：
		 * 1.一共5行
		 * 2.每行打印的数据是 从1开始到n结束。(n的值，第一行是1，第二行是2，第三行是3，第四行是4，第五行是5)
		 * 3.因此，可以通过循环（外层循环）控制行的变化。循环5次。从第1行到第5行
		 * 4.每一行的数据，可以通过一个循环（内层循环）打印 从1到n的数据。(n的值，第一行是1，第二行是2，第三行是3，第四行是4，第五行是5)
		 * 
		 * */
		//不使用循环嵌套
		//第1行
		for(int j = 1; j <= 1; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		//第2行
		for(int j = 1; j <= 2; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		//第3行
		for(int j = 1; j <= 3; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		//第4行
		for(int j = 1; j <= 4; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		//第5行
		for(int j = 1; j <= 5; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		
		System.out.println("-----华丽的分割线-----");
		//使用循环嵌套
		for(int i = 1; i <= 5; i++) {
			for(int j = 1; j <= i; j++) {
				System.out.print(j + " ");
			}
			System.out.println();
		}
	}
循环嵌套示例3：

  1. 需求：打印如下内容：

    1 2 3 4 5

    1 2 3 4

    1 2 3

    1 2

    1

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印如下内容：
//		1 2 3 4 
//		1 2 3 
//		1 2 
//		1 
		//不使用循环嵌套
		//第1行
		for(int j = 1; j <= 4; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		//第2行
		for(int j = 1; j <= 3; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		//第3行
		for(int j = 1; j <= 2; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		//第4行
		for(int j = 1; j <= 1; j++) {
			System.out.print(j + " ");
		}
		System.out.println();
		
		System.out.println("-----华丽的分割线-----");
		
		//循环嵌套
		for(int i = 4; i >= 1; i--) {
			for(int j = 1; j <= i; j++) {
				System.out.print(j + " ");
			}
			System.out.println();
		}
	}
循环嵌套示例4：

  1. 需求：打印九九乘法表。

    1x1=1

    1x2=2 2x2=4

    1x3=3 2x3=6 3x3=9

    …

  2. 代码：

    	public static void main(String[] args) {
		// 需求：打印九九乘法表。
//		1x1=1
//		1x2=2 2x2=4
//		1x3=3 2x3=6 3x3=9
//		... 
		// 不使用嵌套
		// 第1行
		for (int j = 1; j <= 1; j++) {
			System.out.print(j + "x" + 1 + "=" + j * 1 + " ");
		}
		System.out.println();
		// 第2行
		for (int j = 1; j <= 2; j++) {
			System.out.print(j + "x" + 2 + "=" + j * 2 + " ");
		}
		System.out.println();
		// 第3行
		for (int j = 1; j <= 3; j++) {
			System.out.print(j + "x" + 3 + "=" + j * 3 + " ");
		}
		System.out.println();
		// 第4行
		for (int j = 1; j <= 4; j++) {
			System.out.print(j + "x" + 4 + "=" + j * 4 + " ");
		}
		System.out.println();
		// 第5行
		for (int j = 1; j <= 5; j++) {
			System.out.print(j + "x" + 5 + "=" + j * 5 + " ");
		}
		System.out.println();
		// 第6行
		for (int j = 1; j <= 6; j++) {
			System.out.print(j + "x" + 6 + "=" + j * 6 + " ");
		}
		System.out.println();
		// 第7行
		for (int j = 1; j <= 7; j++) {
			System.out.print(j + "x" + 7 + "=" + j * 7 + " ");
		}
		System.out.println();
		// 第8行
		for (int j = 1; j <= 8; j++) {
			System.out.print(j + "x" + 8 + "=" + j * 8 + " ");
		}
		System.out.println();
		// 第9行
		for (int j = 1; j <= 9; j++) {
			System.out.print(j + "x" + 9 + "=" + j * 9 + " ");
		}
		System.out.println();
		
		System.out.println("-----华丽的分割线-----");
		
		for(int i = 1; i <= 9; i++) {
			for(int j = 1; j <= i; j++) {
				System.out.print(j + "x" + 9 + "=" + j * 9 + " ");
			}
			System.out.println();
		}
	}
循环嵌套示例5：

  1. 需求：输出如下图形。

    @@@@@

    @@@@@

    ​ @@@@@

    ​ @@@@@

  2. 代码：

    	public static void main(String[] args) {
		// 需求：打印如下图形。
		// @@@@@
		//  @@@@@
		//   @@@@@
		//    @@@@@
		//分析：
		//一共4行，因此外层循环要循环四次
		//对于每一行：包含3部分（空格、@以及换行符）：即外层循环的循环体包含3部分。
		//第1行 空格是0个，@是5个，换行符是1个
		//第2行 空格是1个，@是5个，换行符是1个
		//第3行 空格是2个，@是5个，换行符是1个
		//第4行 空格是3个，@是5个，换行符是1个
		for(int i = 0; i < 4; i++) {
			for(int j = 0; j < i; j++) {
				System.out.print(" ");
			}
			for(int k = 0; k < 5; k++) {
				System.out.print("@");
			}
			System.out.println();
		}
	}
循环嵌套示例6：

  1. 需求：打印如下图像

    ​ @

    ​ @@@

    @@@@@

    @@@@@@@

  2. 代码：

    	public static void main(String[] args) {
		// 需求：打印如下图形。
		//   @
		//  @@@
		// @@@@@
		//@@@@@@@
		//分析：
		//1.一共四行。外层循环要循环4次
		//2.每一行包含3个部分：空格、@、换行符
		//3.第1行 3个空格  1个@ 1个换行符
		//  第2行 2个空格  3个@ 1个换行符
		//  第3行 1个空格  5个@ 1个换行符
		//  第4行 0个空格  7个@ 1个换行符
		//空格个数和行号的关系是 空格个数 = 4 - 行号
		//@个数和行号的关系是  @个数 = 2 * 行号 - 1
		//换行符是每行1个。
		for(int i = 1; i <= 4; i++) {
			for(int j = 0; j < 4 - i; j++) {
				System.out.print(" ");
			}
			for(int k = 0; k < 2 * i - 1; k++) {
				System.out.print("@");
			}
			System.out.println();
		}
	}
循环嵌套示例7：

  1. 需求：打印如下图形。

    ​ @

    ​ @@@

    @@@@@

    @@@@@@@

    ​ @@@@@

    ​ @@@

    ​ @

  2. 代码：

    	public static void main(String[] args) {
		// 需求：打印如下图形。
		//   @
		//  @@@
		// @@@@@
		//@@@@@@@
		// @@@@@
		//  @@@
		//   @
		//分析：
		//这个菱形可以看做是一个上三角形和一个下三角形拼成的图形。
		//一、首先是上三角形。先用一个循环嵌套打印出来上三角
		//1.一共4行。外层循环要循环4次
		//2.每一行包含3个部分：空格、@、换行符
		//3.第1行 3个空格  1个@ 1个换行符
		//  第2行 2个空格  3个@ 1个换行符
		//  第3行 1个空格  5个@ 1个换行符
		//  第4行 0个空格  7个@ 1个换行符
		//空格个数和行号的关系是 空格个数 = 4 - 行号
		//@个数和行号的关系是  @个数 = 2 * 行号 - 1
		//换行符是每行1个。
		//二、其次是下三角形。也用一个循环嵌套打印出来下三角
		//1.一共是3行。外层循环要循环3次
		//2.每行包含3部分：空格、@、换行符
		//3.第1行  1个空格  5个@ 1个换行符
		//  第2行  2个空格  3个@ 1个换行符
		//  第3行  3个空格  1个@ 1个换行符
		//空格个数和行号的关系是  空格个数与行号相等
		//@个数和行号的关系是  @个数  = (3 - 行号) * 2 + 1
		//换行符是每行1个
		for(int i = 1; i <= 4; i++) {
			for(int j = 0; j < 4 - i; j++) {
				System.out.print(" ");
			}
			for(int k = 0; k < 2 * i - 1; k++) {
				System.out.print("@");
			}
			System.out.println();
		}
		for(int i = 1; i <= 3; i++) {
			for(int j = 1; j <= i; j++) {
				System.out.print(" ");
			}
			for(int k = 1; k <= (3 - i) * 2 + 1; k++) {
				System.out.print("@");
			}
			System.out.println();
		}
	}
循环嵌套示例8：

  1. 需求：求1! + 2! + 3! + 4!的和是多少。

  2. 代码：

    	public static void main(String[] args) {
		//需求：求1! + 2! + 3! + 4!的和是多少。
		//分析：
		//1.内层循环 计算每个数的阶乘  
		//2.外层求 阶层的和。
		long sum = 0;
		for(int i = 1; i <= 4; i++) {
			long num = 1;
			for(int j = 1; j <= i; j++) {
				num *= j;
			}
			sum += num;
		}
		System.out.println(sum);
	}
循环嵌套示例9：

  1. 需求：打印100以内所有的质数。质数：大于1的自然数中，只能被1自身整除的数。

  2. 代码：

    	public static void main(String[] args) {
		//需求：打印100以内所有的质数。质数：大于1的自然数中，只能被1自身整除的数。
		//外层循环：从2开始循环到100
		//内层循环：判断数字是不是质数. 让这个数n从2开始除，一直除到n-1，一旦余数为0，表示不是质数。否则是质数。
		for(int i = 2; i < 100; i++) {
			boolean isPrime = true;
			for(int j = 2; j < i; j++) {
				if(i % j == 0) {
					isPrime = false;
					break;
				}
			}
			if(isPrime) {
				System.out.println(i);
			}
		}
	}
循环嵌套示例10：

  1. 需求：我国古代数学家张邱建在《算经》中出了一道“百钱买百鸡”的问题，题意是这样的：5文钱可以买一只公鸡，3文钱可以买一只母鸡，1文钱可以买3只小鸡。现在用100文钱买100只鸡，那么各有公鸡、母鸡、小鸡多少只？请编写程序实现。

  2. 代码：

    public static void main(String[] args) {
		//我国古代数学家张邱建在《算经》中出了一道“百钱买百鸡”的问题，题意是这样的：
		//5文钱可以买一只公鸡，3文钱可以买一只母鸡，1文钱可以买3只小鸡。
		//现在用100文钱买100只鸡，那么各有公鸡、母鸡、小鸡多少只？请编写程序实现。
		//分析：
		//1. 5文钱买1只公鸡。100文钱最多买20只公鸡。也就是说公鸡的取值范围是：[0,20]
		//2. 3文钱买1只母鸡。100文钱最多买33只母鸡。也就是说母鸡的取值范围是：[0,33]
		//3. 1文钱买3只小鸡。100文钱最多买300只小鸡（因为是最多100只鸡，所以最多是100只）。也就是说小鸡的取值范围是：[0,100] 注：小鸡需要3只3只买
		//假设买了 x只公鸡，y只母鸡，z只小鸡。  5*x + 3*y + z/3 = 100 并且 x + y + z = 100,求x、y、z的组合有哪些
		for(int x = 0; x <= 20; x++) {
			for(int y = 0; y <= 33; y++) {
				for(int z = 0; z <= 100; z += 3) {
					if(5 * x + 3 * y + z / 3 == 100 && x + y + z == 100) {
						System.out.println("公鸡" + x + "只，母鸡" + y + "只，小鸡" + z + "只");
					}
				}
			}
		}
	}
循环嵌套总结

循环嵌套可以看成是普通的循环，只不过循环体是另外一个循环。

for循环、while循环、do…while循环可以相互嵌套。

如果循环嵌套里，内层循环有break，break只能结束内层循环，无法结束外层循环，即：break在哪个循环里，结束哪个循环。

十、循环总结

循环是程序开发中比较常用的语法，循环结构可以让某些代码重复执行。

Java提供了for循环、while循环和do…while循环。

明确知道循环次数使用for循环。

不知道循环次数使用while循环。

至少执行一次循环体的时候使用do…while循环。

开发中要避免死循环，可通过break结束死循环。

break用在循环中，作用是结束循环，只能结束本层循环（循环嵌套时），break通常与if语句连用。

continue用于结束本次循环，进入下一次循环。

循环嵌套时：可以把内层循环看成外层循环的循环体。理论上讲，循环嵌套的层数是无限的。for循环、while循环、do…while循环可以相互嵌套。最常见的是for循环嵌套for循环。

侯东阳
关注
专栏目录
循环 结构
h1091068389的博客
08-21 1901
循环结构，顾名思义指循环重复做相同的事，比如人正常的呼吸，反复的学习，这些都是在重复。在掌握了选择结构if语句后我们知道，当条件满足时，if语句后面的语句执行，但只会执行一次。然而我们发现在日常生活中很多情况下同一件事需要完成很多次，这时候就需要用到我们所提到的循环结构。 在C语言中，循环结构一般又分为3种即：while语句，for语句和do while语句，接下来分别了解一下他们的基本格式以及具体实例。 一、while语句 while的基本结构： while(表达式) 循环语句； 流程图如下所示 其中w.
循环结构的基本概念
zhuyawendeyujing的博客
04-27 271
循环结构的基本概念 计算平均分 ##计算平均数 a = input(“请输入第一个成绩”) b = input(“请输入第二个成绩”) c = input(“请输入第三个成绩”) d = input(“请输入第四个成绩”) e = input(“请输入第五个成绩”) sum = int(a) + int(b) + int© + int(d) + int(e) avg = sum/5 print(“平均分：%.2f”%avg) 存在问题：如果学生有10、100、1000，整个程序代码的结构需要改变，重复的代码
Python之循环结构
12-25
while循环结构 格式: while 表达式： 语句块 执行流程：当程序执行到while语句时，首先判断表达式的真假。若表达式的值为真，则执行缩进的语句块，之后返回表达式继续判断；若表达式的值为假，则跳过缩进的语句块...
Java实验报告——循环结构应用
02-21
在本Java实验报告中，我们关注的是循环结构的应用，特别是在解决实际问题——游戏中生命力购买的最佳策略。实验的主要目的是让学生深入理解变量与常量的定义，掌握while循环、if语句和break语句的使用，以及如何运用...
C语言入门——循环结构练习（内附答案）
10-26
在C语言中，循环结构是编程中非常基础且重要的部分，它允许程序重复执行特定代码块直到满足某个条件为止。本篇文章将通过两个实例来讲解C语言中的循环结构，包括`while`循环和`for`循环的使用。 首先，我们来看第一...
Python程序设计-循环结构说课稿.docx
最新发布
06-12
循环结构程序设计——实现复杂计算程序 一、说教材 1.教材地位分析 教材是由湖北省中小学教材编写组编写的义务教育教科书《信息技术》。其中《循环结构程序设计》是初中信息技术课本第三册的第七单元"Python程序设计...
初中Python程序设计循环结构教学设计方案.pdf
09-30
在提供的文件内容中，我们可以看到与初中Python程序设计的循环结构相关的内容。循环结构是编程中一种非常重要的结构，它能够让程序反复执行某段代码直到满足特定条件。下面，我将详细解读文件中包含的知识点： 1. ...
循环结构的概念
weixin_56913749的博客
04-21 313
循环结构的概念 为什么需要有循环？ 在现实生活中存在着这样的句式： 当……的时候，重复以下操作 （1）…… （2）…… （3）…… 那么在其他语言中（如法语、德语）也应该存在类似的句式，同理在java中也有这样的句式 while(……){ …… …… …… } 循环的要素： 循环的条件和循环体（需要反复执行的操作） ...
JavaScript循环结构的概念
donghua-li的博客
07-28 1521
今天主要学习循环结构，给大家分享下，有什么错误指教下，多多学习下。 生活中的循环场景： 1.食堂阿姨打菜：接过顾客的的餐盘→询问菜品→打菜→打菜→递回餐盘，重复以上过程，直到所有顾客的菜都打完了。 2.看快递员送快递：查看送件地址→赶往目的地→电话告知收件人→收件人签收→交递快件，重复以上过程，直到所有需要送的快递都处理完了。 3.公交司机...... 4.项目流程...... 以
C语言循环结构详解及实战练习
C语言循环结构是编程中至关重要的一部分，它提供了控制程序流程重复执行的能力，使得算法设计更加灵活。本章节主要涵盖以下几个关键知识点： 1. **while语句**：while语句的基本格式是`while (condition) { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值