循环结构-for-while-do..while
1、循环结构_循环概述与基本组成部分
循环结构的基本组成部分,一般可以分成四部分:
1.初始化语句:在循环开始最初执行,而且只做唯一一次。
2.条件判断:如果成立,则循环继续;如果不成立,则循环退出。
3.循环体:重复要做的事情内容,若干行语句。
4.步进语句:每次循环之后都要进行的扫尾工作。
2、循环结构_for循环
public class Demo1For {
/*
格式:
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
执行流程:
执行初始化语句
执行条件判断语句,看其结果是true还是false
如果是false,循环结束
如果是true,继续执行
执行循环体语句
执行条件控制语句
回到1继续
需求:程序模拟折返跑3次的过程
*/
public static void main(String[] args) {
for (int i = 1; i <= 3; i++) {
System.out.println("折返跑");
}
}
}
public class Demo09For {
public static void main(String[] args) {
/*for(初始化语句;条件判断;步进语句){
循环体
}*/
for (int i = 1; i <= 100; i++) {
System.out.println("我错啦!原谅我吧!" + i);
}
System.out.println("程序停止");
}
}
public class Demo2For {
/*
需求:在控制台输出1-5和5-1的数据
分析:
1.从1开始到5结束,设置初始化从1开始
2.设置判断条件为没有到5的时候继续执行,执行到超过5程序结束
3.从1到5,每次增加1,设置条件控制每次+1
4.将反复进行的事情写入循环结构内部,打印对应数据
注意:
1.循环中,控制循环的变量,可以作为逻辑组织到循环体中进行使用的.
2.循环的条件控制语句,不要局限的认为只能是++
*/
public static void main(String[] args) {
//1.从1开始到5结束,设置初始化从1开始
//2.设置判断条件为没有到5的时候继续执行,执行到超过5程序结束
//3.从1到5,每次增加1,设置条件控制每次+1
for (int i = 1; i <= 5; i++) {
//4.将反复进行的事情写入循环结构内部,打印对应数据
System.out.println(i);
System.out.println("---------------");
for (int i = 5; i >= 1; i--) {
System.out.println(i);
}
}
}
}
public class Demo3For {
/*
需求:求1-5之间的数据和,并把求和结果在控制台输出
分析:
1.求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0
2.在循环中初始化一个变量从1开始,不断++,增长到5
3.循环的过程中,将能够代表(1-5)的i变量和sum进行累加
4.当循环执行完毕时,将最终数据打印出来
注意:
如果在今后的需求中,看到了xxxx求和的字样,就要定义一个求和变量
int sum=0;
*/
public static void main(String[] args) {
//1.求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0
int sum = 0;
//2.在循环中初始化一个变量从1开始,不断++,增长到5
for (int i = 1; i <= 5; i++) {
//3.循环的过程中,将能够代表(1-5)的i变量和sum进行累加
//sum=sum +i;
sum += i;
}
//4.当循环执行完毕时,将最终数据打印出来
System.out.println("数据1-5的和为:" + sum);
}
}
public class Demo4For {
/*
需求:求1-100之间的偶数和,并把求和结果在控制台输出
分析:
1.需求是要求和,定义求和变量。
2.循环中获取1-100之间的每一个数值
3.循环的过程中,对每一个数值进行if判断,判断是否是偶数
4.是偶数的话,跟求和变量累加
5.循环结束后,打印最终结果
*/
public static void main(String[] args) {
//1.需求是要求和,定义求和变量
int sum = 0;
//2.循环中获取1-100之间的每一个数值
for (int i = 1; i <= 100; i++) {
//3.循环的过程中,对每一个数值进行if判断,判断是否是偶数
if (i % 2 == 0) {
//4.是偶数的话,跟求和变量累加
sum += i;
}
//5.循环绪束后,打印最终结果
System.out.println("1-100之间的偶数和为:" + sum);
}
}
}
public class Demo5For {
/*
需求:在控制台输出所有的“水仙花数"
水仙花数是一个三位数
水仙花数的个位、十位、百位的数字立方和等于原数
分析:
1.通过循环获取所有的三位数100-999
2.将每一个三位数拆分为个位,十位,百位
3.加入if判断条件,计算是否是水仙花数,是的话输出打印.
*/
public static void main(String[] args) {
//1.通过循环获取所有的三位数100-999
for (int i = 100; i <= 999; i++) {
//2.将每一个三位数拆分为个位,十位,百位
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
//int bai=i/100;
//3.加入if判断条件,计算是否是水仙花数,是的话输出打印。
if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == i) {
System.out.println(i);
}
}
}
}
public class Demo6For {
public static void main(String[] args) {
System.out.println("传智播客");
System.out.println("黑马程序员");
System.out.print("传智专修学院");
System.out.println();//括号里什么都不输入代表直接换行
System.out.print("博学谷");
}
}
public class Demo5For {
/*
需求:在控制台输出所有的“水仙花数”,要求每行打印2个
System.out.print(打印内容);打印后不换行
System.out.println(打印内容);打印后换行
分析:
1.定义变量count,用于保存打印过”的数量,初始值为0
2.在判定和打印水仙花数的过程中,拼接空格,但不换行,并在打印后让count变量+1,记录打印过的数量
3.在每一次count变量+1后,判断是否到达了2的倍数,是的话,换行。
*/
public static void main(String[] args) {
//1.定义变量count,用于保存"打印过"的数量,初始值为0
int count = 0;
for (int i = 100; i <= 999; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == i) {
//2.在判定和打印水仙花数的过程中,拼接空格,但不换行,并在打印后让count变量+1,记录打印过的数量
System.out.print(i + " ");//链接空格
count++;
//3.在每一次count变量+1后,判断是否到达了2的倍数,是的话,换行
if (count % 2 == 0) {
System.out.println();
}
}
}
}
}
3、循环结构_while循环
1、while和for两种循环使用上其实是一样的。只是执行语句摆放位置不同而已。
2、明确循环次数使用for循环,不明确循环次数,建议使用while循环
public class WhileDemo {
/*
完整格式:
初始化语句;
while(条件判断语句){
循环体语句;条件控制语句;
}
执行流程:
1.执行初始化语句
2.执行条件判断语句,看其结果是true还是false如果是false,循环结束
如果是true,继续执行
3.执行循环体语句
4.执行条件控制语句
5.回到o继续
需求:在控制台打印1-100之间所有的数
*/
public static void main(String[] args) {
//需求:在控制台输出1-100之间所有的数
//for循环实现
for (int i = 1; i <= 100; i++) {
System.out.println("i");
}
System.out.println("--------");
//while循环实现
int i = 1;
//while(i<=100);
//千万不要在while后面添加分号,因为会一直判断小于1无限循环下去的
while (i <= 100) {
System.out.println("i");
i++;
}
}
}
//while和for两种循环使用上其实是一样的。
public class Demo10while {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
System.out.println("我错啦!" + i);
}
System.out.println("==============");
int i = 1; //1.初始化语句
while (i <= 10) { //2.条件判断
System.out.println("我错啦!" + i); //3.循环体
i++; //4.步进语句
}
}
}
while循环案例-珠穆朗玛峰
public class WhileTest {
/*
需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),假如我有一张足够大的纸,它的厚度是0.1毫米。
请问,我折叠多少次,可以折成珠穆朗玛峰的高度?
步骤:
1.定义计数器变量,准备用于统计折叠的次数
2.准备纸张厚度变量,珠峰高度变量
3.折叠的过程是多次,所以使用循环,不确定循环次数,使用while循环
进入循环的条件为(厚度没有超过珠峰的高度就折叠)
4.每折叠一次,计数器就要自增(查数)
5.循环结束后,打印计数器变量即可。
*/
public static void main(String[] args) {
//定义一个计数器,初始值为0
int count = 0;
//定义纸张厚度
double paper = 0.1;
//定义珠穆朗玛峰的高度
int zf = 8844430;
//因为要反复折叠,所以要使用循环,但是不知道折叠多少次,这种情况下更适合使用while循环
//折叠的过程中当纸张厚度大于珠峰就停止了,因此继续执行的要求是纸张厚度小于珠峰高度
while (paper <= zf) {
//循环的执行过程中每次纸张折叠,纸张的厚度要加倍
paper *= 2;
//每执行完一次,我都要看一下那厚度有多少
System.out.println(paper);
//在循环中执行累加,对应折叠了多少次
count++;
}
//打印计数器的值
System.out.println("需要折叠:" + count + "次");
}
}
4、循环结构_do-while循环
和for、while循环区别是,执行第一次的时候是直接134内容没有进行条件判断,第二次执行才进行条件判断。
public class DoWhileDemo {
/*
完整格式:
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
执行流程:
1.执行初始化语句2.执行循环体语句
3.执行条件控制语句
4.执行条件判断语句,看其结果是true还是false
如果是false,循环结束
如果是true,继续执行
5.回到1继续
特点:
do..while循环,无论循环条件是否满足,都至少会执行一次循环体。
原因:do..while循环是从上到下依次执行。
*/
public static void main(String[] args) {
//需求:在控制台打印10次黑马程序员
//do...while循环实现
//int i = 11;
//无论循环条件是否满足,都至少会执行一次循环体。
int i = 1;
do {
System.out.println("黑马程序员");
i++;
} while (i <= 10);
//System.out.println("i");//输出为12,因为至少都会执行一次循环体
}
}
public class Demo11Dowhile {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
System.out.println("原谅你啦!起来吧!地上怪凉!" + i);
}
System.out.println("===============");
int i = 1; //1.初始化语句
do {
System.out.println("原谅你啦!起来吧!地上怪凉!" + i);//3.循环体
i++; //4.步进语句
} while (i <= 10); //2.条件判断
}
}
5、三种循环的区别
public class Loop {
/*
for和while的区别:
条件控制语句所控制的自增变量
因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到了
条件控制语句所控制的自增变量
对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用
*/
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
//for循环内部[定义]的变量,在循环结束后,就会从内存中消失
System.out.println("i");
}
//System.out.println("i");
//错误:找不到符号。在for循环结束后,i从内存中消失了。不能再次被访问了
System.out.println("--------");
for (int i = 1; i <= 10; i++) {
//上面定义的i已经循环完成从内存中消失了,在大括号外再定义i不会有影响
System.out.println("i");
}
System.out.println("--------");
//while循环
int a = 1;
while (a <= 5) {
System.out.println("a");
a++;
}
System.out.println("a" + "...");
}
}
public class Demo13LoopDifference {
public static void main(String[] args) {
for (int i = 1; i < 0; i++) {
System.out.println("Hello");
//system.out.println(i);//这一行是错误写法!因为变量i定义在for循环小括号内,只有for循环自己才能用。
System.out.println("================");
}
int i = 1;
do {
System.out.println("World");
} while (i < 0);
//现在已经超出了do-while循环的范围,我们仍然可以使用变量i
System.out.println("i");//因为do-while至少运行了1次,所以输出结果为2
}
}
6、循环控制_break语句(跳转控制语句)
break关键字的用法有常见的两种:
1.可以用在switch语句当中,一旦执行,整个switch语句立刻结束。
2.还可以用在循环语句当中,一旦执行,整个循环语句立刻结束。打断循环。
关于循环的选择,有一个小建议:
凡是次数确定的场景多用for循环;否则多用while循环。do-while循环使用稍微少一些。
public class Demo2Break {
/*
break : 终止循环体内容的执行
注意:使用是基于条件控制的
break语句只能在循环和switch中进行使用.
需求: 模拟20岁工作到80岁, 60岁退休.
*/
public static void main(String[] args) {
for (int i = 20; i <= 80; i++) {
if (i == 60) {
break; // 结束整个循环
}
System.out.println(i + "岁正在上班");
}
}
}
public class Demo14Break {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
//如果希望从第4次开始,后续全都不要了,就要打断循环
if (i == 4) {//如果当前是第4次
break;//那么就打断整个循环
}
System.out.println("Hel10" + i);
}
}
}
7、循环控制_continue语句(跳转控制语句)
另一种循环控制语句是continue关键字。
一旦执行,立刻跳过当前次循环剩余内容,马上开始下一次循环。
public class Demo1Continue {
/*
continue : 跳过某次循环体内容的执行
注意:使用是基于条件控制, 在循环内部使用.
需求: 模拟电梯上行的过程 1-24层, 4层不停.
*/
public static void main(String[] args) {
for (int i = 1; i <= 24; i++) {
if (i == 4) {
continue;
}
System.out.println(i + "层到了~");
}
}
}
8、死循环
public class Loop {
/*
for死循环格式:
fox(;;){
}
while死循环格式:
while(true){
}
do..while死循环格式:
do{
}while(true)
问题: 死循环有应用场景吗?
例如: 键盘录入一个1-100之间的整数
顾虑: 键盘录入是用户操作的, 用户就可能会出现一些误操作的现象
*/
public static void main(String[] args) {
for (; ; ) {
System.out.println("我停不下来了~");
}
while (true) {
System.out.println("我停不下来了~");
}
do {
System.out.println("我停不下来了~");
} while (true);
System.out.println("看看我能被执行吗?~"); // 无法访问的语句
}
}
}
public class Demol6DeadLoop {
public static void main(String[] args) {
for (int i = 1; i <= 10; ) {//忘了写步进语句i++
System.out.println("Hello" + i);//死循环例子
}
}
}
public class Demo16DeadLoop {
public static void main(String[] args) {
while (true) {
System.out.print1n("I Love Java!");
}
//System.out.print1n("Helllo");//死循环没结束,后面写什么都运行不了
}
}
import java.util.Scanner;
public class Test {
/*
需求:程序运行后,用户可多次查询星期对应的减肥计划,直到输入0,程序结束
步骤:
1. 不明确用户操作几次, 使用死循环包裹业务逻辑
2. 匹配到0的时候,使用break结束循环死循环
*/
public static void main(String[] args) {
lo:
while (true) {
System.out.println("请输入您要查看的星期数:");
System.out.println("(如无需继续查看,请输入0退出程序)");
// 1. 键盘录入星期数据,使用变量接收
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
// 2. 多情况判断,采用switch语句实现
switch (week) {
// 3. 在不同的case中,输出对应的减肥计划
case 0:
System.out.println("感谢您的使用");
break lo;
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;
}
}
}
}
9、嵌套循环
所谓嵌套循环,是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环,就是嵌套循环。
总共的循环次数=外循环次数*内循环次数
for(初始化表达式①; 循环条件②; 步进表达式⑦) {
for(初始化表达式③; 循环条件④; 步进表达式⑥) {
执行语句⑤;
}
}
大括号里完整地执行了一次,就认为是一次循环,不管括号里写什么!
public class Demo17LoopHourAndMinute {
public static void main(String[] args) {
for (int hour = 0; hour < 24; hour++) {//外层控制小时
for (int minute = 0; minute < 60; minute++) {//内层控制小时之内的分钟
System.out.println(hour + "点" + minute + "分");
}
}
}
}
10、用循环求出1-100之间的偶数和
题目:求出1-100之间的偶数和。
思路:
1.既然范围已经确定了是1到100之间,那么我就从1、2、3.一直到100这么多数字一个一个进行检查。
2.总共有100个数字,并非所有数字部能用。必须要是偶数才能用,
判断(if语句)偶数:num % 2==0
3.需要一个变量,用来进行累加操作。也就好比是一个存钱罐。
public class Demo12HundredSum {
public static void main(String[] args) {
int sum = 0; //用来累加的存钱罐
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {//如果是偶数
sum += i;
}
}
System.out.println("结果是:" + sum);//结果为2250
}
}
11、Random
import java.util.Random;
public class Demo1Random {
/*
Random : 产生随机数
1. 导包 : import java.util.Random;
导包的动作必须出现在类定义的上面
2. 创建对象 : Random r = new Random();
上面这个格式里面,r 是变量名,可以变,其他的都不允许变
3. 获取随机数 : int number = r.nextInt(10); //获取数据的范围:[0,10) 包括0,不包括10
上面这个格式里面,number是变量名,可以变,数字10可以变。其他的都不允许变
需求: 产生随机数1-10之间的
*/
public static void main(String[] args) {
// 2. 创建对象
Random r = new Random();
for (int i = 1; i <= 10; i++) {
// 3. 获取随机数
int num = r.nextInt(10) + 1; // 1-10
System.out.println(num);
}
}
}
11、猜数字
import java.util.Scanner;
import java.util.Random;
public class Test {
/*
需求:程序自动生成一个1-100之间的数字,使用程序实现猜出这个数字是多少?
当猜错的时候根据不同情况给出相应的提示
如果猜的数字比真实数字大,提示你猜的数据大了
如果猜的数字比真实数字小,提示你猜的数据小了
如果猜的数字与真实数字相等,提示恭喜你猜中了
1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
2. 使用Random产生一个1-100之间的数, 作为要猜的数
3. 键盘录入用户猜的的数据
4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
6. 猜对之后, break结束.
*/
public static void main(String[] args) {
// 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
Random r = new Random();
Scanner sc = new Scanner(System.in);
// 2. 使用Random产生一个1-100之间的数, 作为要猜的数
int randomNum = r.nextInt(100) + 1;
//为了测试程序,可以先把随机数打印出来
System.out.println(randomNum);
// 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
while (true) {
// 3. 键盘录入用户猜的的数据
System.out.println("请输入您猜的数据:");
int num = sc.nextInt();
// 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
if (num > randomNum) {
System.out.println("猜大了");
} else if (num < randomNum) {
System.out.println("猜小了");
} else {
// 6. 猜对之后, break结束.
System.out.println("恭喜,猜中了");
break;
}
}
System.out.println("感谢您的使用");
//加了break,这句话有可能执行到,如果不加break,这句话系统会认为绝对是执行不到的
}
}