一.介绍
除了我们的选择结构外，在我们的java中还有一个重要的结构，叫循环结构，循环结构也是在我们的应用中比较广泛的，所以在这里呢，我们更加详细的解释循环的应用。
在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，决定循环的终止条件。循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。循环语句是由循环体及循环的终止条件两部分组成的。
二.知识点介绍
1、概述
2、循环四要素
3、for循环
4、循环结构-while
5、循环嵌套
6、三种循环的区别
7、无条件分支跳转
三.知识点详解
1、概述
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
2、循环四要素：
要想执行循环，我们得拥有循环执行的条件，循环四要素：
（1）循环变量（变量初始化）：用于计算循环次数的变量。
（2）循环条件（布尔表达式）：这是一个boolean 表达式，这个表达式能决定是否执行循环体。
（3）循环变量改变（步进表达式）：这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。
（4）循环逻辑内容(循环体)：这个部分是循环体语句，也就是我们要多次做的事情。
3、for循环
for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。
3.1、for循环语句的语法格式
格式：
for(初始化表达式①；布尔表达式②；步进表达式④){
循环体③
}
执行流程：
执行顺序： ①②③④>②③④>②③④… ②不满足为止。
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况
流程图：
代码演示：
package com.Test;
/*
循环语句for:最常用的循环语句,一般用于已知循环次数
循环变量初始化 (初始化表达式)
循环出口(布尔表达式)
循环增量(步进表达式)
循环逻辑内容(循环体)
格式:
for(初始化表达式①；布尔表达式②；步进表达式④){
循环体③
}
需求:打印5次我爱java
*/
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args){
//打印5次我爱java
for(int x=0; x<5; x++){
System.out.println("我爱java!"+(x+1));
}
System.out.println("程序结束!");
System.out.println("============="+name+"=============");
}
}
3.2、for循环注意事项
3.2.1、①②③④四个部分均可以为空
当①为空时，注意变量作用域的范围变化
当②为空时，为条件永远为true的死循环
当③为空时，通常没有意义
当④为空时，可以将其加入到循环体中，或同样成为死循环
3.2.2、初始化表达式①的部分可以同时定义多个变量
步进表达式可以同时将多个循环相关变量改变，控制循环条件
代码演示：
package com.Test;
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args){
//打印10次我爱java
//当①为空时，注意变量作用域的范围变化
/*
int x=0;
for(; x<10; x++){
System.out.println("我爱java!"+(x+1));
}
//System.out.println(x);错误: 找不到符号，注意作用域
System.out.println(x);
System.out.println("============="+name+"=============");
===========================分隔符===============================
*/
//当②为空时，为条件永远为true的死循环
/*
for(int x=0; ; x++){
System.out.println("我爱java!"+(x+1));
}
===========================分隔符===============================
*/
//System.out.println("程序结束!");错误: 无法访问的语句
//当③为空时，通常没有意义
/*
for(int x=0; x<10; x++){
}
*/
//当④为空时，可以将其加入到循环体中，或同样成为死循环
/*
for(int x=0; x<10; ){
System.out.println("我爱java!"+(x+1));
//x++;
}
===========================分隔符===============================
*/
/*
磊哥的java历险记-@51博客
初始化表达式①的部分可以同时定义多个变量
步进表达式可以同时将多个循环相关变量改变，控制循环条件
*/
for(int x=0,y=0; x<10; x++,y +=2){
System.out.println("x = " + x + " y = " + y);
}
}
}
3.3、for练习
3.3.1、在控制台输出10次HelloWorld
代码演示：
public class Main {
private final static String name = "磊哥的java历险记-@51博客";
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("============="+name+"=============");
//用循环改进
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld"+x);
}
}
}
3.3.2、获取数据1-5 和5-1
代码演示：
public class Demo02For {
private final static String name = "磊哥的java历险记-@51博客";
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("============="+name+"=============");
//使用for循环
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
System.out.println("============="+name+"=============");
//5-1
for (int i = 5; i>=1; i--) {
System.out.println(i);
}
}
}
3.3.3、求出1-5之间数据之和
代码演示：
public class Main {
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args) {
//1.定义一个初始化变量,记录累加求和,默认值为0
int sum = 0;
//2.使用for循环获取1-5之间的数据
for (int i = 1; i <= 5; i++) {
//3.把每一次for循环获取到的数据累加起来
/*
* 第一次:sum = 0 + 1 = 1
* 第二次:sum = 1 + 2 = 3
* 第三次:sum = 3 + 3 = 6
* 第四次:sum = 6 + 4 = 10
* 第五次:sum = 10 + 5 = 15
*/
//sum = sum + i;用下面方式替代
sum += i;
}
//4.循环结束之后,打印累加结果
System.out.println("sum:"+sum);
System.out.println("============="+name+"=============");
}
}
3.3.4、求出1-100之间偶数和
代码演示：
public class Demo04For {
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args) {
//1.定义一个初始化变量,记录累加求和,初始值为0
int sum = 0;
//2.利用for循环获取1-100之间的数字
for (int i = 1; i <= 100; i++) {
//3.判断获取的数组是奇数还是偶数
if(i%2==0){
//4.如果是偶数就累加求和
sum += i;
}
}
//5.循环结束之后,打印累加结果
System.out.println("sum:"+sum);
System.out.println("============="+name+"=============");
}
}
3.3.5、在控制台输出所有的“水仙花数”
package com.Test;
/*
*
所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
* 举例：153就是一个水仙花数。153 = 1*1*1 + 5*5*5 + 3*3*3
* */
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args) {
//使用for循环获取所有的三位数
for (int i = 100; i < 1000; 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){
System.out.println(i);
System.out.println("============="+name+"=============");
}
}
}
}
4、循环结构_while
4.1、while循环语句使用语法格式
基本格式：
while(布尔表达式) {
循环体语句;
}
扩展格式：
初始化表达式①
while(布尔表达式②){
循环体③
步进表达式④
}
执行流程：
执行顺序： ①②③④>②③④>②③④… ②不满足为止。
①负责完成循环变量初始化。
②负责判断是否满足循环条件，不满足则跳出循环。
③具体执行的语句。
④循环后，循环变量的变化情况。
流程图：
4.2、while练习
4.2.1、输出10次HelloWorld
代码演示：
package com.Test;
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args) {
//使用for循环打印10次HelloWorld
for (int i = 1; i <=10; i++) {
System.out.println("HelloWorld");
}
System.out.println("============="+name+"=============");
//while循环实现打印10次HelloWorld
int i = 1;
while(i<=10){
System.out.println("HelloWorld");
i++;
}
}
}
4.2.3、我们做个 While统计水仙花数有多少个
代码演示：
package StudyJavaSE;
public class WhileShuiXianhuashu {
public static void main(String[] args) {
//1.定义一个统计变量,初始值为0
int count = 0;
//2.使用for循环获取所有的三位数
for(int x=100; x<1000; x++) {
//3.拆分三位数的百位,十位,个位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//4.利用公式判断这个三位数是否为水仙花数,如果是,统计变量++
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
}
System.out.println("水仙花数共有："+count+"个");
count = 0;
//1.定义一个统计变量,初始值为100
int x = 100;
//2.使用while循环获取所有的三位数
while (x<1000) {
//3.拆分三位数的百位,十位,个位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//4.利用公式判断这个三位数是否为水仙花数,如果是,统计变量++
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
x++;
}
//5.循环结束之后,打印统计结果
System.out.println("水仙花数共有："+count+"个");
}
}
4.3、while循环注意事项
（1）与for循环的循环变量作用域不同，for循环的循环变量其作用域仅限于循环体内，而while循环的循环变量作用域不局限在循环体内。
（2）与for循环的循环条件为空是是死循环不同，while循环的循环条件不能为空。
（3）我们经常会使用while(true)的方式根据需求完成一个死循环。
4.4、do while循环语句语法格式
基本格式：
do {
循环体语句;
}while(布尔表达式);
扩展格式：
初始化表达式①
do{
循环体③
步进表达式④
}while(布尔表达式②);
执行流程：
执行顺序： ①③④>②③④>②③④… ②不满足为止。
①负责完成循环变量初始化。
②负责判断是否满足循环条件，不满足则跳出循环。
③具体执行的语句
④循环后，循环变量的变化情况
流程图：
4.5、do while循环注意事项
do while循环的使用特点为无论是否满足条件，均至少会执行一次。do while循环在日常开发中遇到的较少。
4.6、do while练习
4.6.1、输出10次HelloWorld
代码演示：
public class Demo01DoWhile {
public static void main(String[] args) {
//输出10次 HelloWorld
/*
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
*/
//do...while改写
int x=1;
do {
System.out.println("HelloWorld");
x++;
}while(x<=10);
}
}
4.7、While与do_while比较
代码演示：
/*
需求:打印5次我爱java
*/
public class Demo09WhileAndDoWhile{
public static void main(String[] args){
//while
//int i = 0;
int i = 5;
while(i < 5){
System.out.println("我爱java"+(i+1));
i++;
}
//System.out.println(i);
System.out.println("----------------------------------");
//do while
//int j = 0;
int j = 5;
do{
System.out.println("我爱java"+(j+1));
j++;
}while(j < 5);
}
}
5、循环嵌套
循环嵌套并不是一个新的知识点。只是在循环格式中嵌套使用了循环。
如for循环可以嵌套for循环：
………
for(初始化表达式; 循环条件; 操作表达式) {
执行语句
………
}
………
}
5.1、循环嵌套练习:
5.1.1、3排同学进行报数,每组5名同学,打印出我是第x排,第x个!
代码演示：
package com.Test;
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
/*
循环嵌套:循环里边嵌套一个循环
最常用的格式:
for(){
for(){
}
}
需求:3排同学进行报数,每排5名同学,打印出我是第x排,第x个!
我是第1排,第1个!
我是第1排,第2个!
我是第1排,第3个!
我是第1排,第4个!
我是第1排,第5个!
我是第2排,第1个!
我是第2排,第2个!
我是第2排,第3个!
我是第2排,第4个!
我是第2排,第5个!
我是第3排,第1个!
我是第3排,第2个!
我是第3排,第3个!
我是第3排,第4个!
我是第3排,第5个!
*/
public static void main(String[] args){
for(int i=0; i<3; i++){//外层循环可以控制打印的行数
//System.out.println("我是第"+(i+1)+"排");
for(int j=0; j<5; j++){//内层循环可以控制每行打印几个
//System.out.println("我是第"+(j+1)+"个");
System.out.println("我是第"+(i+1)+"排,第"+(j+1)+"个!");
}
}
System.out.println("============="+name+"=============");
}
}
6、三种循环的区别
虽然可以完成同样的功能，但是还是有小区别：
（1）do…while循环至少会执行一次循环体。
（2）for循环和while循环只有在条件成立的时候才会去执行循环体
（3）for循环语句和while循环语句的小区别：
使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提 高内存的使用效率。
循环使用推荐for -- while -- do..while
代码演示：
package com.Test;
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args) {
/*
int x = 3;
while(x<3) {
System.out.println("我想有个PS游戏机");
x++;
}
System.out.println("--------------");
int y = 3;
do {
System.out.println("我想有个PS游戏机");
y++;
}while(y<3);
*/
for(int x=1; x<=10; x++){
System.out.println("爱生活，爱Java");
}
//这里的x无法继续访问
//System.out.println(x);
System.out.println("-----------------");
int y = 1;
while(y<=10) {
System.out.println("爱生活，爱Java");
y++;
}
System.out.println(y);
System.out.println("============="+name+"=============");
}
}
7、无条件分支跳转
在loop/switch选择或者循环过程中，我们总是满足布尔表达条件才能执行对应的代码，然而在这些逻辑过程中，可以使用一些关键字直接跳出正在执行的代码，去执行后边或者指定位置的代码，这些关键字一旦出现就可以跳转语句执行顺序。
（1）break 中断
（2）continue 继续
7.1 break关键字
用来跳出switch语句和循环语句
（1）break使用方式
无法单独使用，必须将break关键字置于switch或循环语句中。
（2）break运行规律
不需要判断任何条件，只要遇到break便直接跳出执行后续代码。会完全跳出选择或者循环结构。
break只能跳出最近的代码块，不能跨越多级代码块。
代码演示：
package com.Test;
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
/*
break语句:可以实现跳出循环
break使用方式
无法单独使用，必须将break关键字置于switch或循环语句中。
break运行规律
不需要判断任何条件，只要遇到break便直接跳出执行后续代码。会完全跳出选择或者循环结构。
break只能跳出最近的代码块，不能跨越多级代码块(多层循环)。
*/
public static void main(String[] args){
//无法单独使用，必须将break关键字置于switch或循环语句中。
//break;// 错误: 在 switch 或 loop 外部中断
//打印10次我想有个PS游戏机
//打印10次我想有个PS游戏机 在打印完第三次的时候跳出循环
/*
for(int i=0; i<10; i++){
if(i==3){
System.out.println("重要是事情说三遍就够了");
break;
}
System.out.println("我想有个PS游戏机"+(i+1));
}
System.out.println("程序结束");
*/
//需求:就让第一排同学报数
for(int i=0; i<3; i++){//外层循环可以控制打印的行数
//System.out.println("我是第"+(i+1)+"排");
for(int j=0; j<5; j++){//内层循环可以控制每行打印几个
//System.out.println("我是第"+(j+1)+"个");
if(i==1){
break;
}
System.out.println("我是第"+(i+1)+"排,第"+(j+1)+"个!");
}
}
System.out.println("============="+name+"=============");
}
}
/*
* private final static String name = "磊哥的java历险记-@51博客";
* System.out.println("============="+name+"=============");
*
* */
7.2、continue关键字
（1）continue使用方式
无法单独使用，必须将continue关键字置于循环语句中。
（2）continue运行规律
不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环。
代码演示：
package com.Test;
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
/*
continue语句:跳出本次循环,执行下一次循环
continue使用方式
无法单独使用，必须将continue关键字置于循环语句中。
continue运行规律
不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环。
*/
public static void main(String[] args){
//continue;//错误: continue 在 loop 外部
/*
我想有个PS游戏机1
我想有个PS游戏机2
我我想有个PS游戏机3
重要是事情说三遍就够了
我想有个PS游戏机5
我想有个PS游戏机6
我想有个PS游戏机7
我想有个PS游戏机8
我想有个PS游戏机9
我想有个PS游戏机10
*/
/*
for(int i=0; i<10; i++){
if(i==3){
System.out.println("重要是事情说三遍就够了");
continue;
}
System.out.println("我想有个PS游戏机"+(i+1));
}
System.out.println("程序结束");
*/
//需求:打印1-10之间的奇数
/*
1
3
5
7
9
*/
for(int i=0; i<10; i++){
if(i % 2 ==0){
continue;
//break;
}
System.out.println(i);
}
System.out.println("============="+name+"=============");
}
}
7.3、循环嵌套练习
代码演示：
package com.Test;
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
//按要求分析结果，并验证
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) {
// 分别写break，continue，说说输出几次
//break;//输出2次
continue;//输出7次
}
System.out.println("我爱Java!"+i);
}
System.out.println("============="+name+"=============");
}
}
7.4、标号语句(标签)跳转
当在双层循环或者循环内有switch选择语句时，我们发现，使用break或者continue所作用的对象均是内层语句，无法直接跳出外层循环，这时就需要使用标号语句跳转了。
（1）表达语句跳转的使用方式
在外层循环外的某行前边，使用后边跟有冒号”:”的标识符，即定义完毕。
使用时当在内层循环使用break或continue时后边紧跟之前定义的标号即可
（2）表达语句跳转的运行规律
当外层循环外定义了标号：内层使用break，终止内外双层循环。内层使用continue，终止内层循环，继续外层循环。
代码演示：
package com.Test;
/*
标号:可以实现跳出多层循环
使用格式:
break 标号;
表达语句跳转的使用方式
在外层循环外的某行前边，使用后边跟有冒号”:”的标识符，即定义完毕。
使用时当在内层循环使用break或continue时后边紧跟之前定义的标号即可。
表达语句跳转的运行规律
当外层循环外定义了标号
内层使用break，终止内外双层循环。
内层使用continue，终止内层循环，继续外层循环。
continue标号
使用格式:
continue 标号;
*/
public class Main{
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args){
//需求:就让第一排同学报数
/*
break
我是第1排,第1个!
我是第1排,第2个!
我是第1排,第3个!
我是第1排,第4个!
我是第1排,第5个!
第一排同学报数结束
continue
我是第1排,第1个!
我是第1排,第2个!
我是第1排,第3个!
我是第1排,第4个!
我是第1排,第5个!
第一排同学报数结束
我是第3排,第1个!
我是第3排,第2个!
我是第3排,第3个!
我是第3排,第4个!
我是第3排,第5个!
*/
itcast:for(int i=0; i<3; i++){//外层循环可以控制打印的行数
//System.out.println("我是第"+(i+1)+"排");
for(int j=0; j<5; j++){//内层循环可以控制每行打印几个
//System.out.println(“我是第”+(j+1)+"个");
if(i==1){
System.out.println("第一排同学报数结束");
//break itcast;
continue itcast;
}
System.out.println("我是第"+(i+1)+"排,第"+(j+1)+"个!");
}
}
System.out.println("============="+name+"=============");
}
}
结语：
文章中概念，代码，演示，都给大家贴出来了，大家自己动手敲一敲代码才是王道，敲代码的过程中就自动理解含义了，千万别看完就觉得学会了，永远不要相信自己是天才!
感谢大家的持续关注！
