代码执行顺序之循环执行：for&while&dowhile&嵌套循环

代码执行顺序之循环执行

循环执行的分类

1. for循环
2. while循环
3. dowhile循环

---

for循环

语法：

for(循环初始化表达式；循环条件表达式；循环后的操作表达式){

​ // 循环体

}

执行步骤分析：

1. 循环初始化表达式最先执行，并且只执行一次

2. 当循环条件表达式为true时，则执行循环体

   当循环条件表达式为fasle时，则跳出循环，执行循环外的语句

3. 当循环体执行完毕，立刻执行循环后的操作表达式

4. 当循环后的操作表达式执行完毕，立刻执行循环条件表达式，判断成不成立

画图分析：

总结：

1. 循环初始化表达式中声明的变量，称为循环变量

2. 循环条件表达式返回结果必须是boolean类型，如果省略循环条件表达式，默认值为ture

3. 循环初始化表达式和循环后的操作表达式没要求，语法编译能通过即可

   代码展示：

   public class ForTest{
       public static void main(String[] args){
           int i = 0;
           for(System.out.println("A");i < 3;System.out.println("C")){
               System.out.println("B");
           }
       }
   }
   

   代码展示：

   public class ForTest{
       public static void main(String[] args){
           for(int i = 1,j = 5;j > -1;i += 2,j -= 3){
               System.out.println("i = " + i + "j = " + j);
           }
       }
   }
   

练习：

1. 输出[1,100]之间的所有整数

   代码展示：

   public class ForTest{
       public static void main(String[] args){
           for(int i = 1;i <= 100;i++){
               System.out.println(i);
           }
       }
   }
   

2. 输出0(包含)到100(包含)之间的数, 分别以递增和递减的方式实现

   代码展示：

   public class ForTest{
       public static void main(String[] args){
           // 递增
           for(int i = 0;i<=100;i++){
               System.out.println(i);
           }
           // 递减
           for(int i = 100;i>=0;i--){
               System.out.println(i);
           }
       }
   }
   

3. 输出1到100之间的奇数和偶数；

   代码展示：

   public class ForTest{
       public static void main(String[] args){
           for(int i = 1;i <= 100;i++){
               if(i % 2 == 0){
                   continue;
               }
               System.out.println("奇数i = " + i);
           }
           for(int i = 2;int i <= 100;i+=2){
               System.out.println("偶数i = " + i);
           }
       }
   }
   

4. 输入一个正整数n，计算1+2+3+…+n的和

   代码实现：

   public class ForTest{
       public static void main(String[] agrs){
           java.util.Scanner input = new java.util.Scanner(System.in);
           System.out.print("请输入一个正整数:");
           int n = input.nextInt();
           int sum = 0;
           for(int i = 1;i<=n;i++){
               sum += i;
           }
           System.out.println(sum);
       }
   }
   

5. 输入一个正整数n，计算1-2+3-4+5-6+…-(n-1)+n的和

   代码展示：

   public class ForTest{
       public static void main(String[] args){
           java.util.Scanner input = new java.util.Scannner(System.in);
           System.out.print("请输入一个正整数:");
           int n  = input.nextInt();
           int sum = 0;
           for(int  i = 1;i<=n;i++){
               if(i % 2 == 0){
                   sum -= i;
               }else{
                   sum += i;
               }
           }
           System.out.println(sum);
       }
   }
   

6. 输出1到1000之间既能被5整除又能被3整除的数，并且每行输出5个。

   代码展示:

   public class ForTest{
       public static void main(String[] args){
           int count = 0;
          for(int i = 1;i<=1000;i++){
              if(i % 5 == 0 && i %  3 == 0){
                  System.out.print(i + "\t");
                  count++;
                  if(count %  5 == 0){
                      System.out.println();
                  }
              }
          }
       }
   }
   

7. 请问以下代码执行完，循环后i的值是多少？

   public class ForTest{
       public static void main(String[] args){
           int i = 1;
           for(;i <= 3;i++){
               System.out.println(i);
           }
           System.out.println(i); // 4
       }
   }
   

   答：循环后的i的结果是4

while循环

语法：

while（循环条件表达式）{

​ // 循环体

}

执行：

1. 判断循环条件表达式是否成立，如果成立就执行循环体，否则跳出循环，执行循环外的语句
2. 当循环体执行完毕，再次去判断循环条件表达式是否成立

注意：循环后的操作表达式放在循环体前|后有本质区别，使用时一定切忌

代码展示：

public class ELTest{
    public static void main(String[] args){
        int i = 1;
        while(i<=10){
            System.out.println(i);
            i++;
        }
    }
}

代码展示

public class ELTest{
    public static void main(String[] args){
        int i = 1;
        while(i <= 10){
            i++;
            System.out.println(i);
        }
    }
}

练习：

1. 输出1到1000之间既能被5整除又能被3整除的数，并且每行输出5个

   代码展示：

   public class ElTest{	
       public static void main(String[] args){
           int count = 0;
           int i = 1;
           while(i<=1000)){
               if(i % 5 == 0 && i % 3 == 0){
                   System.out.println(i + "\t");
                   count++;
                   if(count % 5 ==0){
                       System.out.println();
                   }
               }
              i++;
           }   	
       }
       }
   

---

dowhile循环

语法:

do{

// 循环体

}while(循环条件表达式);

注意：“循环后的操作表达式”在“循环体”的前|后面有本质区别，谨慎使用

实例：类似生活中的先学习后考试,考试通过才能到下一阶段学习

while和dowhile循环的区别：

while：先判断后执行，循环体可能一次也不会执行

dowhile：先执行后判断，循环体至少会被执行一次

循环执行的总结：

for循环最常用，while其次，dowhile几乎不用

循环需要循环变量

1. 循环变量需参与运算，一定要设置好初始值
2. 循环变量不需要参与运算，只用于控制循环次数

死循环不需要循环变量

代码展示：

public class DoWhileTest{
    public static void main(String[] args){
        int i = 1;
        do{
            System.out.println(i);
            i++;
        }while(i <= 10);
    }
}

练习：

1. 输入[1,100]间的所有正整数

   代码展示：

   public class ShowNumTest{
       public static void main(String args[]){
           int i = 1;
           do{
               System.out.println(i);
               i++;
           }while(i<=100);
       }
   }
   

---

关于死循环的讲解

死循环：循环体始终执行，终止不了程序的运行

死循环的分类：

1. 对程序有害的死循环
2. 对程序有利的死循环

对程序有害的死循环：

起因：每趟循环执行完毕都离循环的终止条件越来越远，属于逻辑错误

代码展示：

public class ForTest{
    public static void main(String[] args){
        for(int i = 1;i<=100;i--){
            System.out.println(i);
        }
    }
}

对程序有利的死循环：

需求：不明确循环次数时，可使用死循环

注意：死循环一般配合break关键字使用

代码展示：

public class Test{
	public static void main(String[] args){
        int i = 0;
        do{
            i++;
            if(i == 3){
                break;
            }
            System.out.println(i);
        }while(i < 10);
	}   
}

死循环的用法

针对for循环的死循环，省略“循环条件表达式”，默认为true（使用较少）

语法：

for( ; ；){

​ // 循环体

}

代码展示：

public class ForTest{
    public static void main(String[] args){
        for(;;){
            System.out.println("哈哈");
        }
    }
}

针对while循环的死循环，可读性强，语法便捷(最常用)

语法：

while(true){

​ // 循环体

}

代码展示：

public class WhileTest{
    public static void main(String[] args){
        while(true){
            System.out.println("嘻嘻");
        }
    }
}

---

break关键字(最常用)

使用场合：

1. 循环(for、while{} 、do{}while();）
2. switch语句

作用：

1. 若作用于switch语句，用于结束switch语句，执行switch语句外的代码
2. 若作用于循环，用户结束当前循环，执行循环外的语句

代码展示：

// Switch 
public class SwitchTest{
    public static void main(String[] args){
        java.util.Scanner input = new java.util.Scanner(System.in);
        int month =  input.nextInt();
        switch(month){
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out,println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
				System.out.println("秋季");
                break;
            default:
                System.out.println("季节不存在");
        }
    }
}

// for
public class ForTest{
    public static void main(String[] args){
   		for(int i = 1;i<=10;i++){
			if(i == 3){
                break;
            }
            System.out.println(i);
        }
        System.out.println("over");
    }
}

// dowhile
public class DowhileTest{
    public static void main(String[] args){
        int i = 0;
        do{
            i ++ ;
            if(i == 3){
                break;
            }
            System.out.println(i);
        }while(i <= 9);
    }
}

// while
public class WhileTest{
    public static void main(String[] args){
        int i = 0;
        while(i<=9){
            i++;
            if(i==3){
                break;
            }
            System.out.println(i);
            
        }
        System.out.println("over");
    }
}

注意：break作用于离其最近的循环语句|switch语句

画图分析：

---

return关键字

使用场合：

只能在方法中使用

作用：

结束当前方法

return和break区别：

break可用于结束当前循环，循环后的代码会正常执行

return用于结束当前方法，循环后的代码将不会 被执行

代码展示：

public class ReturnTest{
 	public static void main(String[] agrs){
    	for(int i = 0;i< 9 ;i++){
            if(i == 3){
                return;
            }
            System.out.println(i);
        } 
        System.out.println("over");
 	}
}

注意：在return&break之后不要书写任何代码，因为这些代码是死代码，永远不会被执行

练习：

1. 韩信点兵，三人一组余两人，五人一组余三人，七人一组余四人，请问需要多少士兵？

   代码展示：

   public class  ForTest{  
      public static void main(String[] args){
      		
           for(int i = 1;;i++){
               if( i % 3 == 2 && i % 5 == 3 && i % 7 == 4){
               	System.out.println("韩信点兵需要的人数为"+ i);
                   break;
               }
             }
           
       }
   }
   

   总结：“死循环”一般和“break”关键字一起使用，当不明确循环次数时，建议直接使用死循环

2. 输入一个任意整数，判断它是否为质数，如果是质数就输出“是质数”，否则输出‘不是质数’。

   质数：除了1和它本身之外,不能被其他数整除的正整数称质数。

   代码展示：

    // 方式一：
   public class MethodOne{
      public static void main(String[] args){
      		     Scanner input  = new Scanner(System.in);
        		 System.out.println("请输入一个正整数:");
         		 int  num = input.nextInt();
        		 boolean flag = true;
        	     for(int i = 2;i< num;i++){
            	 if(num % i == 0){
                 	flag = false;
                 	break;
            	 }
        	 }
        	 if(flag){
             	System.out.println("num 是一个质数，num = " + num);
        	 }else{
             	System.out.println("num不是一个质数，num = " + num);
         	}
   	}
   }
   

   // 方式二：
   public class MethodTWo{
   public static void main(String[] args){
      Scanner input = new Scanner(System.in);
      System.out.println("请输入一个正整数:");
      int num  = input.nextInt();
      int i = 2;
      for(;i < num;i++){
          if(num % i == 0){
              break;
          }
      }
      if(num == i){
          System.out.println("num 是一个质数，num = " + num);
      }else{
          System.out.println("num不是一个质数，num = " + num);
      }
   }
   }
   

---

continue关键字(使用较少)

作用：

结束当次或本次循环，继续执行下一次循环

使用场合：

只能在循环中使用

注意：在return、continue和break之后，不要写代码，因为这些是死代码，永远不会执行

代码展示：

public class ContinueTest{
    public static void main(String[] args){
        for(int i = 0;i<=10;i++){
            if(i == 2){
                continue;
            }
            System.out.println(i);
        }
    }
}

public class ContinueTest{
    public static void main(String[] args){
        int i = 10;
        while(i<=20){
            if(i==15){
                continue;
            }
            System.out.println(i);
            i++;
        }
    }
}

画图分析：

练习：

1. 使用continue关键字实现输出1到100之间能被5整除的数

   代码展示：

   public class ContinueTest{
       public static void main(String[] args){
           if(int i = 1; i <= 100;i++){
           	if(i % 5 != 0){
                   continue;
               }    
               System.out.println(i);
           }
           
       }
   }
   

   ---

   嵌套循环

   特点：外出循环变量变化一次，内侧循环的循环变量完整执行一整遍

   注意：外侧循环用来控制行数，内侧循环用来控制空格数和星星数

   练习：

   1. 在控制台先打印矩形

      如图所示：
      

      代码展示：

      public class Demo{
          public static void main(String[] args){
              for(int i = 0;i < 3;i++){
                  for(int j = 1;j < 10;j++){
                      System.out.prnt("*")
                  }
                  System.out.println();
              }
          }
      }
      

   2. 打印平行四边形

      如图所示：
      

      代码展示：

      public class Test{
          public static void main(String[] args){
          	for(int i = 0;i < 4;i++){
      			// 内侧循环：用来控制空格数
      			for(int j = 0;j < i;j++){
      				System.out.print(" ");
      			}
      			// 内侧循环：用来控制星星数
      			for(int j  = 0;j < 9;j++){
      				System.out.print("*");
      			}
      			System.out.println();
      		}
          }
      }
      

   3. 打印等腰三角形

      如图所示：
      

      代码展示：

      import java.util.Scanner;
      public class DouleLoopTest{
          public static void main(String[] args){
              Scanner input = new Scanner(System.in);
      		System.out.println("请输入行数");
      		int num = input.nextInt();
              // 外侧循环用来控制行数
      		for(int i = 0;i<num;i++){
                  // 内侧循环用来控制空格数
      			for(int j = 0;j< num - i - 1;j++){
      				System.out.print(" ");
      			}
                  // 内侧循环用来控制星星数
      			for(int j = 0;j < 2 * i + 1;j++){
      				System.out.print("*");
      			}
      			System.out.println();
      		}
          }
      }
      

   4. 打印菱形

      如图所示：
      

      代码展示：

      import java.util.Scanner;
      public class DoubleLoopTest{
          public static void main(String[] args){
             Scanner input = new Scanner(System.in);
      	        System.out.print("请输入菱形的行数：");
      	        int length =  input.nextInt();
      	        // 外侧循环 ： 用来控制行数
      	        for(int i = 0;i < length / 2 + 1; i++){
      	        	// 内侧循环1：用于控制空格数
      				for(int j = 0; j < length/2+1 - i - 1; j++) {
      					System.out.print(" ");
      				}
      				// 内侧循环2：用于控制星星数
      				for(int j = 0; j < 2 * i + 1; j++) {
      					System.out.print("*");
      				}
      				System.out.println();
      	    	}
      	         // 外侧循环用来控制行数
      	        for(int i = 0;i < length / 2;i++){
      	            // 内侧循环用来控制空格数
      	            for(int j = 0;j < i + 1;j++){
      	                System.out.print(" ");
      	            }
      	            // 内侧循环用来控制星星数
      	            for(int j = 0;j < 2 * (length / 2 - i -1) + 1;j++){
      	                System.out.print("*");
      	            }
      	            System.out.println();
      	        }
          }
      }
      

   5. 打印空心菱形

      如图所示：
      

      代码展示：

      import java.util.Scanner;
      public class DoubleLoopTest{
          public static void main(String[] args){
              Scanner input = new Scanner(System.in);
              System.out.println("请输入菱形的行数：");
              int length = input.nextInt();
              for(int i = 0 ;i < length / 2 + 1;i++){
                  for(int j = 0;j < length / 2 + 1 - i - 1;j++){
                      System.out.print(" ");
                  }
                  for(int j = 0;j < 2 * i + 1;j++){
                      if(j == 0 || j == 2 * i){
                          System.out.print("*");
                      }else{
                          System.out.print(" ");
                      }
                  }
                  System.out.println();
              }
              for(int i = 0; i < length / 2 ;i ++ ){
                  for(int j = 0;j < i + 1;j++){
                      System.out.print(" ");
                  }
                  for(int j = 0;j < 2 * (length/2-i-1) + 1;j++){
                      if(j == 0 || j == 2 * (length/2-i-1)){
                          System.out.print("*");
                      }else{
                          System.out.print(" ");
                      }
                  }
                  System.out.println();
              }
                 
          }
      }
      

   6. 打印乘法口诀表

      如图所示：
      

      代码展示：

      public class NineNineTable {
      	public static void main(String[] args) {
      		// 打印九九乘法口诀表
      		// 外侧循环控制行数
      		for(int i = 1;i <= 9;i++){	
      			for(int j = 1 ;j <= i;j++){
      				System.out.print(j+ "*" + i  + "=" + (j*i)+"\t");
      			}
      			System.out.println();
      		}
      	}
      }
      

   7. 输入[0,9]之间的一个数，输出数字构成的1~5位整数的和，如输入2，则计算出2 + 22 + 222 + 2222 + 22222之和

      代码展示：

      import java.util.Scanner;
      public class DoubleLoopTest01 {
      	public static void main(String[] args) {
      		Scanner input = new Scanner(System.in);
      		System.out.print("请输入[0,9]之间的整数:");
      		 int num = input.nextInt();
      		 int result = 0;
      		 int sum = 0;
      		 for(int i = 0;i < 5;i++){
      			 result *= 10;
      			 result += num;
      			 sum += result;
      		 }
      		 System.out.println(sum);
      	}
      }
      

   8. 搬砖问题：36块砖，36个人搬，男搬4块，女搬3块，两个小孩搬1块，要求一次搬完，问需要男、女、小孩各多少人？

      代码展示：

      public class DoubleLoopTest01{
          public static void main(String[] args){
              for(int x = 0;x < 9 ;x++){
      			for(int y  = 0 ;y < 12;y++){
      				for(int z = 0;z < 36;z += 2){
      					if(x+y+z == 36 && x * 4 + y * 3 + z / 2 == 36){
      						System.out.println("男人：" + x + " 女人：" + y + " 小孩：" + z);
      					}
      				}
      			}
      		}
          }
      }
      

      此文章于11月25日编辑完毕，小编也是个初学者，或许有些内容写的有错误的，我对自己的要求是：有错改之，无错加勉。还望大家能在评论区指点迷津，不胜感激，同时也希望大家口下留情！！