测试Java中 for while do while if switch foreach表达式的使用！！！

提示：

---

---

以下是本篇文章正文内容，下面案例可供参考

一、if语句

if： 用来判断某个值或表达式的结果为ture 或者 false，从而执行不同的语句块。
else语句属于可选语句。
if语句又分为单分支if语句和多分支if语句。
单分支if语句分为2中情况： 条件符合或者不符合从而执行相应的代码块（示例）：

		boolean flag = true;
        if (flag){
            //当括号内的表达式值为真时执行此处代码
            System.out.println("表达式为真");
        }else {
            // 不为真时执行此处的代码
            System.out.println("表达式为假");
        }
        //-----------------示例2：---------------------
	    int age = 20;
        if (age >= 18){
            System.out.println("成年人");
        }else {
            System.out.println("未成年人");
        }

else if 多分支语句

上面的单分支语句很显然并不能执行我们想要的年龄段的各种结果。我们将上面代码用else if 多分支语句进行补充（示例：）

	    //多分支语句会在if判断的条件不满足时，继续判断else if 的值如果不满足继续向下依次进行判断，
        //如果找到满足的条件则执行对应的代码块语句，如果都不满足则执行else 的 语句块
        // 年龄段在 0~17岁之间 
        if (age > 0 && age <18 ){
            System.out.println("未成年人");
            // 年龄段在 18~34岁之间 
        }else if (age>=18 && age <35){
            System.out.println("成年人");
        }else if (age >= 35 && age < 50){
            System.out.println("中年人");
        }else if (age >= 50 && age <=150){
            System.out.println("老年人");
        }else if (age <= 0){
            System.out.println("您是不是打错了！");
        }else  {
            System.out.println("我没见岁数这人大的！");
        }

通过上面的多分支语句代码我们完善了人的各个年龄段之间所对应的年龄范围

二、switch 分支语句（枚举语句）

switch 枚举语句：可对某个值的取值范围中的单个值进行判断，如果等于则执行 case：的语句。
如果没有case语句所对应的值将会执行default语句(default语句是可选的)。
特别注意每个case语句结束后要加上 break； 代表跳出语句，否则该程序会依次执行下面的所有case语句。
JDK7以后可以枚举字符串。

            String str = "1";
            switch (str){
	                //当括号内的值为 “1”时执行下面的代码
	            case "1":
	                System.out.println("1111111");
	                break;
	               //当括号内的值为 “2”时执行下面的代码
	            case "2":
	                System.out.println("2222222");
	                break;
	                //如果没有值被匹配则执行default语句
	             default:
	                System.out.println("????????");
	                break;
             }

用switch来对枚举类的枚举

代码如下：

    //定义了一个枚举类它所包含5个值
enum WeeK{
    //enum class
    Jonathan,GoldenDel,RedDel,Winesap,Cortland;
}
	//使用 switch 进行枚举 (JDK5之后)
		//创建了枚举类的实例
          WeeK weeK = WeeK.Jonathan;
               switch (weeK){
                case RedDel:
                    System.out.println("week枚举类的值是 "+"RedDel");
                    break;
                case Winesap:
                    System.out.println("week枚举类的值是 "+"Winesap");
                    break;
                case Cortland:
                    System.out.println("week枚举类的值是 "+"Cortland");
                    break;
                case Jonathan:
                    System.out.println("week枚举类的值是 "+"Jonathan");
                    break;
                case GoldenDel:
                    System.out.println("week枚举类的值是 "+"GoldenDel");
                    break;
                default:
                        System.out.println("未找到");
               }

上面的代码我们创建了一个枚举类，并用switch语句对该类进行枚举，相信你已经看到了每个case语句后都加了break关键字， 接下来演示下switch中break关键字的作用。

	  int month = 4;
            String season;
            //以下代码 没有每个case后跟break，将会造成匹配到的值依次执行直到遇到break，可以根据业务逻辑自行选择
            switch (month){
                case 12:
                	 System.out.println("12月");
                case 1:
                	 System.out.println("1月");
                case 2:
                	 System.out.println("2月");
                    season = "Winter";
                    System.out.println(season);
                    break;
                case 3:
                    System.out.println("3月");
                case 4:
                	 System.out.println("4月");
                case 5:
                 	System.out.println("5月");
                    season = "Spring";
                    System.out.println(season);
                    break;
                case 6:
                	 System.out.println("6月");
                case 7:
                	 System.out.println("7月");
                case 8:
                	 System.out.println("8月");
                    season = "Summer";
                    System.out.println(season);
                    break;
                case 9:
                	 System.out.println("9月");
                case 10:
                	 System.out.println("10月");
                case 11:
                	 System.out.println("11月");
                    season= "Autumn";
                    System.out.println(season);
                    break;
                   default:
                       season = "Bogus Month";
                       System.out.println(season);
            }

从上面的例子我们可以看到，如果case语句结束后没有加break，则会依次执行下个case的语句。直到找到了break；才会停止。break关键字也同样可以应用在循环结构中。

三、for循环语句

for : 经常应用在已知循环次数的语句中，如数组遍历与赋值等

      语法格式：
            for（初始值；循环条件；迭代体 ）{
                循环体
            }
        执行顺序：
                1.执行初始值（初始化只执行一次）
                2.判断是否满足循环条件
                    如果满足则执行循环体 执行 完成后执行迭代体
                    迭代体执行完后，继续判断是否满足循环条件
                    直到不满足循环条件后 整个语句结束
                3.不满足则不执行任何语句
                4.迭代体在循环体结束后执行

代码演示：

			//用for循环来计算100内的正整数之和
			//定义一个用来保存计算结果的变量
            int sum = 0 ;
            for (int i = 1 ; i < 101 ; i++ ){
                sum+=i; // sum = sum + i ;
            }
          System.out.println("1~100整数之和为： "+sum);

for循环嵌套打印出九九乘法表

       for (int i = 1 ; i <= 9 ; i++){
            for (int j = 1 ; j <= i ; j++){
                System.out.print(j+"*"+i+"="+(i*j)+" ");
            }
            System.out.println();
        }

for循环嵌套执行逻辑：
1.先判断外层循环是否满足条件。如果满足执行内层的循环结构，并依次判断内层
2.直到没有下个内层循环，则从当前的循环语句开始执行，当前循环结构执行完毕后
3.返回父级的循环结构执行（父级的循环机构也包括了子类本身）
4.直到最外层的父级循环结构执行完毕，至此嵌套循环执行完成

总的来说嵌套循环的执行次数等于外层乘内层

for循环中的break与continue

有些时候我们需要在循环语句中某个时刻跳出循环（break）或者
结束本次循环并进行下次循环（continue）；以下代码演示了这两个关键字的使用

例子:

	//当 i 的值为50时结束循环体；
	 for (int i = 1 ; i <= 100; i++ ) {
            System.out.print(i +" ");
            if (i == 50){
                break;
            }
      }
	//----------------------------------------------------------
	//当 i 能被 10 整除时 跳过本次循环
	  for (int i = 1 ; i <= 100 ; i++){
           if (i % 10 == 0 ){
               continue;
           }
           System.out.print(i+" ");
      }

带标记的 循环结构

我们可以将某个循环结构命名，并使用break 或continue 来进行控制

	//不使用标记之前，只能跳出本次循环，仍然会被外层循环所执行
	 for (int i = 0 ; i < 6 ; i++){
            for (int j = 0 ; j <6  ; j++){
                System.out.println("j=" + j +"\t i="+i);
                if ( i == 3 && j == 3  ){
                    System.out.println("----------");
                    break ;
                }
            }
        }
	// 使用标记后，直接跳出了标记（test：）所在的整个循环体
	 test:
        for (int i = 0 ; i < 6 ; i++){
            for (int j = 0 ; j <6  ; j++){
                System.out.println("j=" + j +"\t i="+i);
                if ( i == 3 && j == 3  ){
                    System.out.println("----------跳出标记 test 位置处的循环");
                    break test;
                }
            }
        }

四、while 循环 与 do while 循环

while 与for 逻辑相同只是不同的写法，本质上while 循环更适合对方法的返回值 进行循环判断，已知次数的循环建议使用for循环。
do while 循环语句则与其他循环结构不同 ，do while 至少会进行一次执行循环不管表达式是否满足。
举个栗子：

		//while 循环 语法格式  先定义初始值，判断表达式，执行循环体
        int i= 0 ;
        while (i<10){
            System.out.println(i);
            i++;
        }
        // while 无限循环方式
        	while(true){
        		System.out.println("无限循环中");
        	}
        // do while 语法格式 ,先执行do语句块，在判断while（）内表达式，符合条件后继续执行
        // 不满足不执行循环，但此时do已经执行了一次（至少执行一次）
        int j = 2;
	  	do {
	        System.out.println("123");
	        j++;
	        //尽管 j >5 为false 但程序还是执行了一次
	     }while (j >5);	
	     

五、增强型for循环------》 foreach循环

不需要数组或者集合的索引和大小进行遍历(JDK5之后)
代码演示：

        int [] arr = new int[10];
         //使用循环对数组赋值
        for (int i = 0 ; i < arr.length ; i++){
            arr[i]=i*10;
        }
        //foreach遍历
          //此处的ele就等于数组里的每个元素，arr为数组名，int 为遍历的数据类型
        for (int ele : arr) {
            System.out.println(ele);
        }
        //foreach遍历集合。
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Hello World!");
        arrayList.add("This Is a Test");
        arrayList.add("Java");
        arrayList.add("OOP");
        arrayList.add("AOP");
        arrayList.add("Python");
        //foreach遍历集合
        for (String ele:arrayList) {
            System.out.println(ele);
        }
        //这里使用了forEach中的Lambda式遍历集合，
        arrayList.forEach(ele-> System.out.println(ele));

总结

ok。以上就是本文的全部内容，如有勘误，还请各位多多包涵、指正。
创作不易，望君三连。您的支持就是我的动力！！！