Java基础：循环控制语句

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+"个");

}

}

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

}

}`

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+"次");

}

}

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

}

}

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

}

}

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‘        换行

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

}

}

}