Java基础：循环控制语句
有三种:for,while,do...while
for循环语句：
A:格式
for(初始化语句;判断条件语句;控制条件语句){
循环体语句;
}
执行流程：
a:执行初始化语句
b:执行判断条件语句
如果这里是true，就继续
如果这里是false，循环就结束
c:执行循环体语句
d:执行控制条件语句
e:回到b
B:注意事项
a:判断条件语句无论简单还是复杂，结果是boolean类型
b:循环体语句如果是一条，可以省略大括号，但是不建议
c:有分号就没有左大括号，有左大括号就没有分号
Demo: 需求：请在控制台输出10次"HelloWorld" |
class ForDemo { public static void main(String[] args) { //最原始的做法 System.out.println("HelloWorld"); System.out.println("HelloWorld"); System.out.println("HelloWorld"); System.out.println("HelloWorld"); System.out.println("HelloWorld"); System.out.println("HelloWorld"); System.out.println("HelloWorld"); System.out.println("HelloWorld"); System.out.println("HelloWorld"); System.out.println("HelloWorld"); System.out.println("----------");
//这种做法不好,代码的重复度太高。 //所以呢，我们用循环改进 for(int x=1;x<=10;x++) { System.out.println("HelloWorld"); } } } |
Code: 请在控制台输出数据1-10 |
class ForDemo2 { public static void main(String[] args) { //原始做法 System.out.println(1); System.out.println(2); System.out.println(3); System.out.println(4); System.out.println(5); System.out.println(6); System.out.println(7); System.out.println(8); System.out.println(9); System.out.println(10);
System.out.println("-------------");
//如何改进呢?用循环改进 for(int x=1; x<=10; x++) { System.out.println(x); }
System.out.println("-------------");
//从0开始 for(int x=0; x<10; x++) { System.out.println(x+1); } } } |
Code: 求出1-10之间数据之和
分析： 0+1=1 1+2=3 3+3=6 6+4=10 10+5=15 ...
由此可见我们要定义两个变量： 一个变量用于存储第一个加数，第一个加数其实保存的是以前的所有数据和。默认初始化值应该是0。 一个变量用于存储第二个加数，第二个加数其实就是每次的数据变化的值。
|
class ForDemo3 { public static void main(String[] args) { //原始做法 System.out.println(1+2+3+4+5+6+7+8+9+10);
//定义第一个加数 int sum = 0;
for(int x=1; x<=10; x++) { //这里的x其实是第二个加数 sum = sum + x; /* 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 ... */
//sum += x; }
System.out.println("sum:"+sum); } } |
Code: A:求1-100之和。 B:求出1-100之间偶数和
|
class ForDemo4 { public static void main(String[] args) { //求1-100之和。 int sum1 = 0;
for(int x=1; x<=100; x++) { sum1 +=x; }
System.out.println("1-100之和是："+sum1); System.out.println("------------------");
//求出1-100之间偶数和 //方式1 int sum2 = 0;
for(int x=1; x<=100; x++) { if(x%2 == 0) { sum2 += x; } }
System.out.println("1-100偶数之和是："+sum2); System.out.println("------------------");
//方式2 int sum3 = 0;
for(int x=0; x<=100; x+=2) { sum3 += x; }
System.out.println("1-100偶数之和是："+sum3); System.out.println("------------------"); } } |
Code: 求5的阶乘。
什么是阶乘呢? n! = n*(n-1)! 规则 n! = n*(n-1)*(n-2)*...*3*2*1
求和思想。 求阶乘思想。
|
class ForDemo5 { public static void main(String[] args) { //定义最终结果变量 int jc = 1;
//这里的x其实可以直接从2开始 //for(int x=1; x<=5; x++)
for(int x=2; x<=5; x++) { jc *=x; }
System.out.println("1-5的阶乘是："+jc); } } |
Code: 在控制台输出所有的"水仙花数" 分析： 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。 举例：153就是一个水仙花数。 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
A:三位数其实是告诉了我们范围。 B:通过for循环我们就可以实现获取每一个三位数 但是麻烦是如何获取这个三位数的个,十,百位上的数据
我们如何获取一个数据的个,十,百呢? 假设有个一个数据:153 ge: 153%10 = 3 shi: 153/10%10 = 5 bai：153/10/10%10 = 1 qian：x/10/10/10%10 wan: x/10/10/10/10%10 ...
C:让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较 如果相同，就把该数据在控制台输出。
|
class ForDemo6 { public static void main(String[] args) { //三位数其实是告诉了我们范围。 for(int x=100; x<1000; x++) { int ge = x%10; int shi = x/10%10; int bai = x/10/10%10;
//让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较 if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) { //如果相同，就把该数据在控制台输出。 System.out.println(x); } } } } |
Code: 请在控制台输出满足如下条件的五位数 个位等于万位 十位等于千位 个位+十位+千位+万位=百位 分析： A:五位数就告诉了我们范围。 B:分解每一个五位数的个，十，百，千，万位上的数据 C:按照要求进行判断即可
|
class ForDemo7 { public static void main(String[] args) { //五位数就告诉了我们范围。 for(int x=10000; x<100000; x++) { //分解每一个五位数的个，十，百，千，万位上的数据 int ge = x%10; int shi = x/10%10; int bai = x/10/10%10; int qian = x/10/10/10%10; int wan = x/10/10/10/10%10;
//按照要求进行判断即可 if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) { System.out.println(x); } } } } |
Code: 统计"水仙花数"共有多少个 分析： A:首先必须知道什么是水仙花数 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。 举例：153就是一个水仙花数。 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 B:定义统计变量，初始化值是0 C:三位数告诉了我们范围，用for循环就可以搞定 D:获取每一个三位数的个，十，百的数据 E:按照要求进行判断 F:如果满足要求就计数。
|
class ForDemo8 { public static void main(String[] args) { //定义统计变量，初始化值是0 int count = 0;
//三位数告诉了我们范围，用for循环就可以搞定 for(int x=100; x<1000; x++) { //获取每一个三位数的个，十，百的数据 int ge = x%10; int shi = x/10%10; int bai = x/10/10%10;
//按照要求进行判断 if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) { //如果满足要求就计数。 count++; } }
System.out.println("水仙花数共有"+count+"个"); } } |
Code: 请统计1-1000之间同时满足如下条件的数据有多少个： 对3整除余2 对5整除余3 对7整除余2 分析： A:定义统计变量,初始化值是0 B:1-1000之间是一个范围，用for很容易就可以实现。 C:每个数据要同时满足如下要求 x%3==2 x%5==3 x%7==2 D:如果满足条件，统计数据++即可，最后输出统计变量
|
class ForDemo9 { public static void main(String[] args) { //定义统计变量,初始化值是0 int count = 0;
//1-1000之间是一个范围，用for很容易就可以实现。 for(int x=1; x<=1000; x++) { /* 每个数据要同时满足如下要求 x%3==2 x%5==3 x%7==2 */ if(x%3==2 && x%5==3 && x%7==2) { count++; System.out.println(x); } }
//输出数据 System.out.println("满足这样条件的数据共有："+count+"个"); } } |
while循环语句格式：
基本格式
while(判断条件语句) {
循环体语句;
}
扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
Demo: |
class WhileDemo { public static void main(String[] args) { //输出10次"HelloWorld" //for语句版 for(int x=0; x<10; x++) { System.out.println("HelloWorld"); } System.out.println("--------------"); //while语句版 int x=0; while(x<10) { System.out.println("HelloWorld"); x++; }
} } |
Code: 求出1-100之和
初始化语句; while(判断条件语句) { 循环体语句; 控制条件语句; }
for(初始化语句;判断条件语句;控制条件语句) { 循环体语句; }
|
class WhileDemo2 { public static void main(String[] args) { //求出1-100之和 //for语句版本 int sum = 0;
for(int x=1; x<=100; x++) { sum+=x; }
System.out.println("sum:"+sum); System.out.println("--------"); //while语句版本 int sum2 = 0;
int y=1; while(y<=100) { sum2+=y; y++; }
System.out.println("sum2:"+sum2); System.out.println("--------"); } } |
Code: 统计水仙花数有多少个 |
class WhileDemo3 { public static void main(String[] args) { //for循环版本 int count = 0;
for(int x=100; x<1000; x++) { int ge = x%10; int shi = x/10%10; int bai = x/10/10%10;
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) { count++; } }
System.out.println("count:"+count); System.out.println("------------");
//while循环版本 int count2 = 0;
int y = 100; while(y<1000) { int ge = y%10; int shi = y/10%10; int bai = y/10/10%10;
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) { count2++; }
y++; }
System.out.println("count2:"+count2); } }` |
循环结构(for循环和while循环的区别)：
while循环和for循环的区别?
使用区别：如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。
因为变量及早的从内存中消失，可以提高内存的使用效率。
其实还有一种场景的理解:
如果是一个范围的，用for循环非常明确。
如果是不明确要做多少次，用while循环较为合适。
class WhileDemo4 {
public static void main(String[] args) {
//for循环实现
for(int x=0; x<10; x++) {
System.out.println("11111");
}
//这里不能在继续访问了
//System.out.println(x);
//while循环实现
int y = 0;
while(y<10) {
System.out.println("11111");
y++;
}
//这里是可以继续访问的
System.out.println(y);
}
}
code： 我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。 请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度? 分析： A:定义一个统计变量，默认值是0 B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度 我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度 C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度? 折叠一次有什么变化呢?就是厚度是以前的2倍。 D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++ E:输出统计变量。
|
class WhileDemo5 { public static void main(String[] args) { //定义一个统计变量，默认值是0 int count = 0;
//最高山峰是珠穆朗玛峰：8848m这是最终的厚度 //我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度 //为了简单，我把0.01变成1，同理8848就变成了884800 int end = 884800; int start = 1;
while(start<end) { //只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++ count++;
//折叠一次有什么变化呢?就是厚度是以前的2倍。 start *= 2;
System.out.println("第"+count+"次厚度是"+start); }
//输出统计变量。 System.out.println("要叠"+count+"次"); } } |
do...while循环的基本格式：
do {
循环体语句;
}while(判断条件语句);
扩展格式；
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
demo： |
class DoWhileDemo { public static void main(String[] args) { //输出10次HelloWorld。 int x = 0; do { System.out.println("HelloWorld"); x++; }while(x<10);
System.out.println("--------------");
//求和1-100 int sum = 0; int a = 1; do { sum += a; a++; }while(a<=100);
System.out.println(sum); } } |
循环语句的区别:
do...while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
那么，我们一般使用哪种循环呢?
优先考虑for，其次考虑while，最后考虑do...while
Demo: |
class DoWhileDemo2 { public static void main(String[] args) { int x = 3; while(x < 3) { System.out.println("111"); x++; }
System.out.println("--------------");
int y = 3; do { System.out.println("1111"); y++; }while(y < 3); } } |
注意死循环：
A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
B:两种最简单的死循环格式
while(true){...}
for(;;){...}
循环嵌套：
demo： 需求：请输出一个4行5列的星星(*)图案。 结果： ***** ***** ***** *****
循环嵌套：就是循环语句的循环体本身是一个循环语句。
通过结果我们知道这样的一个结论： 外循环控制行数 内循环控制列数
|
class ForForDemo { public static void main(String[] args) { //原始做法 System.out.println("*****"); System.out.println("*****"); System.out.println("*****"); System.out.println("*****"); System.out.println("-------------");
//虽然可以完成需求，但是不是很好 //如果是多行多列就会比较麻烦 //所以我们准备改进 //如何改进呢? //我先考虑如何实现一行*的问题 //System.out.println("*****"); //我们要想的是如何实现一次输出一颗*的问题 //System.out.println("*"); //System.out.println("*"); //现在虽然可以一次一颗*，但是却换行了，我要求不能换行，怎么办呢? //输出语句的另一种格式：System.out.print(); 这个是不带换行的 //System.out.print("*"); //System.out.print("*"); //System.out.print("*"); //System.out.print("*"); //System.out.print("*"); //如果我要在一行上打出多颗*，比较麻烦，而代码是重复的，所以我决定用循环改进 for(int x=0; x<5; x++) { System.out.print("*"); } //我们可以通过空的输出语句实现换行：System.out.println(); System.out.println();
//既然我可以打出一行，我就可以打出第二行 for(int x=0; x<5; x++) { System.out.print("*"); } //我们可以通过空的输出语句实现换行：System.out.println(); System.out.println();
//同理打出第三行，第四行 for(int x=0; x<5; x++) { System.out.print("*"); } //我们可以通过空的输出语句实现换行：System.out.println(); System.out.println();
//既然我可以打出一行，我就可以打出第二行 for(int x=0; x<5; x++) { System.out.print("*"); } //我们可以通过空的输出语句实现换行：System.out.println(); System.out.println(); System.out.println("-----------------"); //同样的代码出现了4次，说明我们程序写的不好，用循环改进 for(int y=0; y<4; y++) { for(int x=0; x<5; x++) { System.out.print("*"); } //我们可以通过空的输出语句实现换行：System.out.println(); System.out.println(); } } } |
code： /* 需求：请输出下列的形状 * ** *** **** ***** */
|
class ForForDemo2 { public static void main(String[] args) { //通过简单的观察，我们看到这是一个行是5，列数是变化的形状 //我们先打印出一个5行5列的形状 for(int x=0; x<5; x++) { for(int y=0; y<5; y++) { System.out.print("*"); } System.out.println(); }
System.out.println("--------------");
//我们实现了一个5行5列的形状 //但是这不是我们想要的 //我们要的是列数变化的 //列数是如何变化的呢? //第一行：1列 y=0,y<=0,y++ //第二行：2列 y=0,y<=1,y++ //第三行：3列 y=0,y<=2,y++ //第四行：4列 y=0,y<=3,y++ //第五行：5列 y=0,y<=4,y++ //在看外循环x的变化，恰好就是x=0,1,2,3,4 //所以这个最终版的程序就是如下 for(int x=0; x<5; x++) { for(int y=0; y<=x; y++) { System.out.print("*"); } System.out.println(); } } } |
code： 在控制台输出九九乘法表
我们先把这个九九乘法表看出是这样的一个形状： * ** *** **** ***** ****** ******* ******** *********
注意： '\x' x表示任意，这种做法叫转移字符。
'\t' tab键的位置 '\r' 回车 '\n' 换行
|
跳转控制语句
break:中断
continue:继续
return:返回
code： break:中断的意思 使用场景： A:switch语句中 B:循环语句中。 (循环语句中加入了if判断的情况) 注意：离开上面的两个场景，无意义。
如何使用呢? A:跳出单层循环 B:跳出多层循环 要想实现这个效果，就必须知道一个东西。带标签的语句。 格式： 标签名: 语句
|
class BreakDemo { public static void main(String[] args) { //在 switch 或 loop 外部中断 //break;
//跳出单层循环 for(int x=0; x<10; x++) { if(x == 3) { break; } System.out.println("HelloWorld"); }
System.out.println("over"); System.out.println("-------------");
wc:for(int x=0; x<3; x++) { nc:for(int y=0; y<4; y++) { if(y == 2) { //break nc; break wc; } System.out.print("*"); } System.out.println(); } } } |
code： continue:继续
使用场景： 循环中。离开此场景无意义。
测试，找到和break的区别： break:跳出单层循环 continue:跳出一次循环，进入下一次的执行
|
class ContinueDemo { public static void main(String[] args) { for(int x=0; x<10; x++) { if(x == 3) { //break; continue; }
System.out.println(x); } } |
return:返回 其实它的作用不是结束循环的，而是结束方法的。 |
class ReturnDemo { public static void main(String[] args) { for(int x=0; x<10; x++) { if(x == 2) { System.out.println("退出"); //break; //continue; return; }
System.out.println(x); }
System.out.println("over"); } } |
需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是， 每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱， 请问，经过多少天，小芳才可以存到100元钱。
分析： A:小芳的妈妈每天给她2.5元钱 double dayMoney = 2.5; B:她都会存起来 double daySum = 0; C:从第一天开始存储 int dayCount = 1; D:经过多少天，小芳才可以存到100元钱。 double result = 100; E:这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱， 说明要判断dayCount的值，如果对5整除就减去6元钱。 daySum -= 6; 由此还隐含了一个问题，就是如果不是5的倍数天的话，钱要累加 daySum += dayMoney; F:因为不知道是多少天，所以我用死循环，一旦超过100元我就退出循环。 |
class WhileDemo { public static void main(String[] args) { //每天要存储的钱是2.5元 double dayMoney = 2.5;
//存钱的初始化值是0 double daySum = 0;
//从第一天开始存储 int dayCount = 1;
//最终存储不小于100就不存储了 int result = 100;
//因为不知道是多少天，所以我用死循环， while(true) { //累加钱 daySum += dayMoney;
//一旦超过100元我就退出循环。 if(daySum >= result) { System.out.println("共花了"+dayCount+"天存储了100元"); break; }
if(dayCount%5 == 0) { //花去6元钱 daySum -= 6; System.out.println("第"+dayCount+"天花了6元钱"); }
//天数变化 dayCount++; } } } |
