个人中心
gpt4 book ai didi

Java语法基础之循环结构语句详解

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 28 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java语法基础之循环结构语句详解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、循环结构 。

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环.

循环语句的组成:

初始化语句：一条或者多条语句，这些语句完成一些初始化操作.

判断条件语句：这是一个boolean 表达式，这个表达式能决定是否执行循环体.

循环体语句：这个部分是循环体语句，也就是我们要多次做的事情.

控制条件语句：这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束.

eg：在控制台输出10次"HelloWorld"时， 。

初始化语句：定义初始化为第一次.

判断条件语句：次数不能超过10次.

循环体语句：输出”HelloWorld”语句.

控制条件语句：次数变化为下一次.

2、循环结构(for循环语句) 。

for循环语句格式:

for(初始化语句;判断条件语句;控制条件语句) {          循环体语句;     } 。

执行流程:

A:执行初始化语句 。

B:执行判断条件语句，看其结果是true还是false：如果是false，循环结束；如果是true，继续执行.

C:执行循环体语句 。

D:执行控制条件语句 。

E:回到B继续 。

流程图:

Java语法基础之循环结构语句详解

注意事项:

（1）判断条件语句的结果是一个boolean类型 。

（2）循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略.

（3）一般来说：有左大括号就没有分号，有分号就没有左大括号 。

代码举例:

1、求出1-100之间偶数和:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*
   需求：
     A:求1-100之和。
     B:求出1-100之间偶数和
*/
class ForTest1 {
   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( "------------------" );
   }
}

2、求5的阶乘:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
   需求：求5的阶乘。
  
   什么是阶乘呢?
     n! = n*(n-1)! 规则
     n! = n*(n-1)*(n-2)*...*3*2*1
    
   求和思想。
   求阶乘思想。
*/
class ForTest2 {
   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);
   }
}

3、在控制台输出所有的“水仙花数”:

  。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
 
   需求：在控制台输出所有的”水仙花数”
  
   分析：
     我们都不知道什么叫"水仙花数"，你让我怎么做呢?
    
     所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
     举例：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 ForTest3 {
   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);
       }
     }
   }
}

3、循环结构(while循环语句) 。

while循环语句格式:

while(判断条件语句) {          循环体语句;    } 。

   //扩展格式    初始化语句;    while(判断条件语句) {          循环体语句;          控制条件语句;     } 。

流程图:

Java语法基础之循环结构语句详解

for循环和while循环的区别:

for循环语句和while循环语句可以等价转换，但还是有些小区别的.

（1）使用区别:

控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率.

（2）场景区别:

for循环适合针对一个范围判断进行操作while循环适合判断次数不明确操作 。

代码举例:

我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度？

  。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/*
   我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
   请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
 
   分析：
     A:定义一个统计变量，默认值是0
     B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度
      我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
     C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
      折叠一次有什么变化呢?就是厚度是以前的2倍。
     D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
     E:输出统计变量。
*/
 
class WhileTest01 {
   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+ "次" );
   }
}

4、循环结构(do…while循环语句) 。

基本格式:

do { 。

循环体语句,

}while((判断条件语句);[/code] 。

扩展格式:

初始化语句,

do { 。

循环体语句,

控制条件语句,

} while((判断条件语句);[/code] 。

流程图:

Java语法基础之循环结构语句详解

5、循环结构的区别及注意事项:

三种循环语句其实都可以完成一样的功能，也就是说可以等价转换，但还是有小区别的

do…while循环至少会执行一次循环体。for循环和while循环只有在条件成立的时候才会去执行循环体 。

1、注意事项:

写程序优先考虑for循环，再考虑while循环，最后考虑do…while循环.

如下代码是死循环:

while(true){} 。

for(;;){} 。

2、循环的嵌套使用：就是循环语句的循环体本身是一个循环语句 。

（1）题目一：请输出一个4行5列的星星(*)图案:

提示：外循环控制行数，内循环控制列数 。

  。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*
   需求：请输出下列的形状
     *
     **
     ***
     ****
     *****
 
     提示：外循环控制行数，内循环控制列数
*/
class ForForTest01 {
   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();
     }
   }
}

（2）题目二：在控制台输出九九乘法表:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/*
   需求：在控制台输出九九乘法表。
  
   首先我们写出九九乘法表：
     1*1=1
     1*2=2  2*2=4
     1*3=3  2*3=6  3*3=9
     1*4=4  2*4=8  3*4=12  4*4=16
     ...
     1*9=9  2*9=18  3*9=27  ...
    
   我们先把这个九九乘法表看出是这样的一个形状：
     *
     **
     ***
     ****
     *****
     ******
     *******
     ********
     *********
    
   注意：
     '\x' x表示任意，这种做法叫转移字符。
    
     '\t'  一个制表符的位置（tabtab键）
     '\r'  回车
     '\n'  换行
*/
class ForForTest02 {
   public static void main(String[] args) {
     for ( int x= 0 ; x< 9 ; x++) {
       for ( int y= 0 ; y<=x; y++) {
         System.out.print( "*" );
       }
       System.out.println();
     }
     System.out.println( "--------------" );
     //为了使用数据，我们从1开始
     for ( int x= 1 ; x<= 9 ; x++) {
       for ( int y= 1 ; y<=x; y++) {
         System.out.print(y+ "*" +x+ "=" +y*x+ "\t" );
       }
       System.out.println();
     }
   }
}

运行效果:

Java语法基础之循环结构语句详解

6、跳转控制语句:

前面我们已经说过了，Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，比如说，我想在某个循环知道到某一步的时候就结束，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断.

break 中断 continue 继续 return 返回 。

1、跳转控制语句(break):

break的使用场景:

~在选择结构switch语句中 。

~在循环语句中（循环语句中加入了if判断的情况） 。

注：离开使用场景的存在是没有意义的 。

break的作用:

A:跳出单层循环 。

B:跳出多层循环 。

要想实现这个效果，就必须知道一个东西。带标签的语句。标签名要符合Java的命名规则 。

格式:

标签名: 语句 。

代码举例:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/*
   控制跳转语句：
     break:中断
     continue:继续
     return:返回
  
   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();
     }
   }
}

第38行，我们给外面的循环加了一个标签叫wc，然后在第42行跳转出这个标签.

运行效果:

Java语法基础之循环结构语句详解

注：实际开发中，几乎用不到跳转多层循环这个功能.

2、跳转控制语句(continue):

continue的使用场景:

在循环语句中离开使用场景的存在是没有意义的 。

continue和break的区别:

break 跳出单层循环continue 跳出一次循环，进入下一次的执行.

效果如下:

Java语法基础之循环结构语句详解

面试题:

?
1
2
3
4
5
6
7
for ( int x= 1 ; x<= 10 ; x++) {
     if (x% 3 == 0 ) {
       //在此处填写代码
 
     }
     System.out.println( "Java学习" );
   }

在上面代码的第4行填入一行代码，满足一下条件:

我想在控制台输出2次:"Java学习" break,

我想在控制台输出7次:"Java学习" continue,

我想在控制台输出13次:"Java学习" System.out.println("Java学习"),

3、跳转控制语句(return) 。

return关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法，跳转到上层调用的方法.

说白了：return的作用不是结束循环，而是结束方法.

效果如下:

Java语法基础之循环结构语句详解

循环语句结合break的练习:

面试题：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱.

代码实现:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/*
   需求：小芳的妈妈每天给她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++;
     }
   }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：http://www.cnblogs.com/smyhvae/p/4150599.html 。

最后此篇关于Java语法基础之循环结构语句详解的文章就讲到这里了,如果你想了解更多关于Java语法基础之循环结构语句详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

28 4 0
文章推荐： 全面解析Java观察者模式
文章推荐： Java内部类之间的闭包和回调详解
文章推荐： VBS教程：VBScript 语句-Select Case 语句
文章推荐： Linux宝塔面板7.30推出文件外链分享功能
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com