Java基础:循环控制语句

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++;

}

}

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

以上是 Java基础:循环控制语句 的全部内容, 来源链接: utcz.com/z/391466.html

回到顶部