Java的循环结构及嵌套循环
Java的循环结构
while 循环结构
do...while 循环结构
for 循环结构
Java的嵌套循环
概念
循环控制语句
break
continue
return
foreach 循环
Java8集合自带的foreach以及流的foreach

Java的循环结构
Java 总共有三种循环结构，分别是while、do…while、for。
while 循环结构
while 循环语法：
while(布尔表达式) {
	//功能语句
}

代码执行顺序：

判断小括号中的值是否为 true，如果为 true，执行功能语句。
执行完功能语句，继续判断小括号中的值，如果为 true，继续执行功能语句。
直到判断小括号中的值为 false，跳出循环。

do…while 循环结构
do…while 语法结构：
do {
    //功能语句
} while(布尔表达式);

代码执行顺序：

首先执行 do 结构体里面的功能代码一次。
第一次判断 while() 结果为 ture。
执行 do 循环体。
第二次判断 while() 结果为 ture。
执行 do 循环体。
…
第 n 次判断 while() 结果为 false 循环结束。

和while的区别：

语法结构上的区别。
while 语句是先判断条件是否成立再执行语句，条件不符合后终止。do…while 是先执行语句再判断条件是否成立，条件不符合后终止。
do…while 循环至少执行一次功能语句。

for 循环结构
for 语法结构：
for (循环初始化语句A; 循环判断语句B; 循环后语句D) {
	//功能语句C
}

执行顺序：

循环初始化语句A执行一次。
B --> true ----> C ----> D。
B --> true ----> C ----> D。
…
B --> false，循环结束。

特点：

for ( ; ; ) {不加功能语句}，死循环。
for ( ; ; ) 后直接跟功能语句（1句）死循环。
for ( ; ; ) 后跟两句功能语句，第二句报错，for 无法访问的语句。

注意事项:

当 for (int i = 1; i <= 10; i++) 时 i 是属于该结构体内的变量，外部无法访问。

Java的嵌套循环
概念
循环嵌套，循环里面还有循环，可以嵌套多层，不同的循环结构相互之间也可以嵌套。
例如：
//控制打印行数
for(int i = 1;i<=5;i++){   
	for(int k = 1; k <= 5 - i; k++) {
		//控制打印一行的内容
		System.out.print(" ");
	}
	for(int j = 1; j <= i; j++) {
		//控制打印一行的内容
		System.out.print("* ");
	}
	System.out.println(); 
}

建议：

实际开发中不要嵌套太深,一般情况下嵌套一次足以。
循环控制语句
break
特点：

循环结构结束不等于方法结束，for 循环结构体后面的语句还会正常运行
break 只是终止当层循环：
如果在内层想要终止外层循环：可以给外层循环取一个别名，然后使用break 名字;结束外层循环。

例如：
class BreakTest {
    public static void main(String[] args) {
          test:for(int i = 0; i <= 5; i++) {
              System.out.println(i);
              for(int j = 0; j <= 5; j++) {
                if(j == 3) {
					break test;
				}
			}
		} 
	}
}

continue
特点： 跳过当层当次循环，继续下一次循环
return
特点： 在循环中使用时结束方法，表示结束当前的方法
注意事项：

break、coutinue、return，后面都不能写语句。编译会报错：访问不到。
foreach 循环
foreach 语句是 Java1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发人员提供了极大的方便。

foreach 语句是 for 语句的特殊简化版本，但是 foreach 语句并不能完全取代for语句，然而，所有的 foreach 语句都可以改写为 for 语句版本。

foreach 并不是一个关键字，习惯上将这种特殊的 for 语句格式称之为“foreach”语句。

foreach的语句格式：
for(元素类型t 元素变量x : 遍历对象obj) {
	//引用了 x 的 java 语句;
}


foreach 相对于 for 循环，代码减少了，但是 foreach 依赖 IEnumerable（IEnumerable是一个接口，它定义一个方法 GetEnumerator，它返回一个 IEnumerator 接口，这允许只读访问一个集合，然后实现 IEnumerable 的集合可以与 foreach 语句一起使用）接口。在运行的时候效率低于普通 for 循环。当然了，在处理不确定循环次数的循环，或者循环次数需要计算的情况下，使用 foreach 比较方便。而且 foreach 的代码经过编译系统的优化后，和 for 循环的循环类似。可以说，foreach 语句是 for 语句的特殊简化版本，在遍历数组、集合方面，foreach 为开发人员提供了极大的方便。在进行复杂的循环设计时，还是应该使用 for 循环。

使用场景：

如果只是遍历集合或者数组，用 foreach 好些，快些。
如果对集合中的值进行修改，并且确定循环次数就要用 for 循环了。

Java8集合自带的foreach以及流的foreach
Iterable接口中的默认实现：
default void forEach(Consumer<? super T> action) {  
  Objects.requireNonNull(action);                        
    for (T t : this) {        
      action.accept(t);    
    } 
}

Java8流使用 foreach 打印所有的偶数示例：
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
list.stream()
  .filter(n -> n % 2 == 0)
  .forEach(System.out::println);

使用集合的 foreach 迭代所有元素并打印示例：
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
list.forEach(System.out::println);

使用 foreach 迭代Map：
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
	
// 1.Map entries
map.entrySet().forEach(System.out::println);

// 2.Map keys
map.keySet().forEach(System.out::println);

// 3. Map values
map.values().forEach(System.out::println);

自定义操作Map中的元素：
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

// 1.Map entries
Consumer<Map.Entry<String, Integer>> action = entry -> {
	System.out.println("Key is " + entry.getKey());
	System.out.println("Value is " + entry.getValue());
	System.out.println();
};
map.entrySet().forEach(action);

java为我们提供了while  do-while   for三种循环结构

一.while语法结构：

while(条件（布尔类型的）){

// 循环体具体做什么事情

}
while循环执行流程：

一个循环可能会循环执行多次


第一次判断条件true，继续执行
第二次判断条件true，继续执行
第三次判断条件true，继续执行
。。。。。
直到第n次判断条件false，终止循环

举例：

常用语法结构

int i = 0;				//A循环初始化语句

while( i<=10 ){		//B循环判断语句

// 循环体具体做什么事情//C循环功能语句

i++;						//D循环后语句

}

A  ----->只会执行一次

B  ----->true---->C---->D

B  ----->true---->C---->D

B  ----->true---->C---->D

…

B  ----->false  循环结束
二.	do-while 语法结构

do{

// 循环体

}while(条件);
while循环执行流程：

首先执行do结构体里面的功能代码一次
第一次判断while()结果为ture
执行do循环体…
第二次判断while()结果为ture
执行do循环体…
…
第n次判断…while()…flase循环结束

dowhlie 一定会执行一次循环体，while不一定会执行一次循环体
三.for语法结构

for(初始A;条件判断B;循环后操作C){

//循环体C

}
for的执行流程：

初始化语句会执行一次；只会执行一次

整个for循环结构中的  A 只会执行一次

循环第一次：A→B(true)→D→C

第二次：B(true)→D→C

第三次：B(true)→D→C

…

第n次： B(false)  结束整个循环

四、嵌套循环

概念：循环嵌套  循环里面还有循环，可以嵌套多层，不同的循环结构相互之间也可以嵌套。

for(){

for(){

}

}

问题与代码：
文件名称：循环结构与选择结构嵌套
作者：邓哲
时间：2016年9月


知识点总结：要先搞清顺序在进行嵌套
学习心得：流程图一定要对流程十分清晰。

1.选择结构

if语句

格式1： if (关系表达式) {

语句体;

}

其它语句;

public static void main(String[] args) {
                System.out.println("开始");
                //定义两个变量 
                int a = 10;
                int b = 20;
                //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b 
                if (a == b) {
                    System.out.println("a等于b");
                }
                //需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
                int c = 10;
                if (a == c) {
                    System.out.println("a等于c");
                }
                System.out.println("结束");
            }

运行结果



格式2：

if (关系表达式)

{ 语句体1;

} else {

语句体2;

}

其它语句;

public static void main(String[] args) {
            System.out.println("开始");
            //定义两个变量 
            int a = 10; int b = 20; b = 5; 
            // 需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b 
            if (a > b) {
                System.out.println("a的值大于b");
            } else {
                System.out.println("a的值不大于b");
            }
            System.out.println("结束");
        }

运行结果



-格式3

if (关系表达式1) {

语句体1;

} else if (关系表达式2) {

语句体2;

}
public static void main(String[] args) {
                //小明的考试成绩未知，可以使用键盘录入的方式获取值 
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入一个分数：");
                int score = sc.nextInt();
                //由于奖励种类较多，属于多种判断，采用if...else...if格式实现 
                // 为每种判断设置对应的条件 
                // 为每种判断设置对应的奖励 
                // 数据测试：正确数据，边界数据，错误数据 
                if (score > 100 || score < 0) {
                    System.out.println("你输入的分数有误");
                } else if (score >= 95 && score <= 100) {
                    System.out.println("山地自行车一辆");
                } else if (score >= 90 && score <= 94) {
                    System.out.println("游乐场玩一次");
                } else if (score >= 80 && score <= 89) {
                    System.out.println("变形金刚玩具一个");
                } else {
                    System.out.println("胖揍一顿");
                }
            }


选择结构switch语句

switch(表达式) {

case 常量值1:

语句体1;

break;

case 常量值2:

语句体2;

break;

…

default:

语句体n+1;

break;

}

//其它语句

public static void main(String[] args) {
                //定义月份变量，判断季节 
                int month = 6;
                //switch语句实现选择 
                switch (month) {
                    case 1:
                        System.out.println("冬季");
                        break;
                    case 2:
                        System.out.println("冬季");
                        break;
                    case 3:
                        System.out.println("春季");
                        break;
                    case 4:
                        System.out.println("春季");
                        break;
                    case 5:
                        System.out.println("春季");
                        break;
                    case 6:
                        System.out.println("夏季");
                        break;
                    case 7:
                        System.out.println("夏季");
                        break;
                    case 8:
                        System.out.println("夏季");
                        break;
                    case 9:
                        System.out.println("秋季");
                        break;
                    case 10:
                        System.out.println("秋季");
                        break;
                    case 11:
                        System.out.println("秋季");
                        break;
                    case 12:
                        System.out.println("冬季");
                        break;
                    default:
                        System.out.println("你输入的月份数字有误");
                        break;
                }
            }

2.循环结构
概述

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个

循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

for循环

格式：

for(初始化表达式①; 布尔表达式②; 步进表达式④){

循环体③

}

//其它语句

public static void main(String[] args) {
                //需求：输出数据1-5 
                for (int i = 1; i <= 5; i++) {
                    System.out.println(i);
                }
                System.out.println("--------");
                //需求：输出数据5-1 
                for (int i = 5; i >= 1; i--) {
                    System.out.println(i);
                }
            }

运行结果



2. while循环

格式：

初始化表达式①

while(布尔表达式②){

循环体③

步进表达式④

}

//其它语句
public static void main(String[] args) {
                //for循环实现打印10次HelloWorld 
                for (int i = 1; i <= 10; i++) {
                    System.out.println("HelloWorld");
                }
                //while循环实现打印10次HelloWorld //定义初始化变量 
                int i = 1; //循环条件<=10
                while (i <= 10) {
                    System.out.println("HelloWorld");
                    //步进 
                    i++;
                }
            }

运行结果



3. do  while循环

格式：

初始化表达式①

do{

循环体③

步进表达式④

}while(布尔表达式②);

//其它语句
public static void main(String[] args) {
                int x = 1;
                do {
                    System.out.println("HelloWorld");
                    x++;
                } while (x <= 10);
            }

运行结果同上

循环跳转

break语句：

使用场景：终止switch或者循环

在选择结构switch语句中

在循环语句中

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

 public static void main(String[] args) {
                for (int i = 1; i <= 10; i++) {
                    if (i % 5 == 0) {
                        break;
                    }
                    System.out.println("HelloWorld" + i);
                }
            }

运行结果



continue语句

使用场景：结束本次循环，继续下一次的循环

只能使用在循环语句中
public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 5 == 0) {
                continue;
            }
            System.out.println("HelloWorld" + i);
        }
    }

运行结果


3.循环嵌套
所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数
public static void main(String[] args) {
        //打印2021年至2023年月份 
        // 年份是外循环，3年；月份是内循环，12月 
        for (int i = 2021; i <= 2023; i++) {
            for (int j = 1; j <= 12; j++) {
                //不换行打印星号 
                System.out.print(i + "年" + j + "月 ");
            }
            //内循环打印12个月后，需要一次换行 
            System.out.println();
        }
    }

运行结果