对于循环结构的不同分析
对于for循环，for循环可以内控和外控。
do while 循环和while 循环有区别
do while 循环比while 循环是一定会多一次循环
do while 循环是无论是否符合条件先进行循环再进行判断，
但是while 循环是假如不成立就不进行循环。
for循环可以使用局部的变量和外部变量，而while循环终止是必须使用
外部变量。
另外从循环的已知数量可以想，for使用在已知循环次数的循环里面
while是使用在未知循环次数。这个在我的另一篇文章字符串计算
长度时候用过。
在使用区别上，for循环结束之后，for循环控制的局部变量在内存栈就
被垃圾货收器释放了，但是while循环结束之后，控制的量内存仍然存在，
这个使用看情况的。for循环使用就会提高内存的利用率。
个人体验在小数目计算过程中，for循环比while循环更快
但是在千万级别上的大数计算，两者的速度没有差异。但是本人在学校OJ网站
做题感觉for比较好用，就是感觉这样可以不用让循环体占太多的内存。

代码执行顺序之循环执行

循环执行的分类

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

前言：

最近在看面试题的时候，做到了一些关于它们的一些选择题，我也有点疑惑，所以求助于百度，然后我也没有找到确切的答案，下面给出2个选择题谈谈我个人的看法。

选择题1：

下列关于for循环和while循环的说法中那个是正确的？（）

A、while循环能实现的操作，for循环也都能实现

B、while循环判断条件一般是程序结果，for循环判断条件一般是非程序结果

C、两种循环任何时候都可替换

D、两种循环结构中都必须有循环体，循环体不能为空

答案：A、C

解释：

A：我没有找到可以反对的例子，所以A项正确

B：如果while循环判断条件一般是程序结果，那在循环体里面会执行什么判断呢，暂时没有遇到，毕竟用while循环的情况还是比较少的，感觉B项错误

C：这个暂时没有找到可以反对的例子，所以C项正确

D：首先两种循环结构中都必须有循环体，如下所示：

证明for循环必须有循环体：

证明while循环必须有循环体：

其次for循环的循环体可以为空，而while循环的循环体不一定能为空，如下所示：

证明for循环循环体可以为空：

证明while循环循环体不一定能为空：

选择题2：

说法中正确的是（）

A、for循环完全可以用while循环替代。

B、while循环完全可以用do{}while循环替代。

C、while循环完全可以用for循环替代。

D、do{}while循环完全可以用while循环替代。

E、do{}while循环和while循环均完全可以用for循环替代。

答案：A、C、D、E

解释：

A：没有找到可以反对的例子，所以A正确

B：有些while循环不能用do while循环代替，如下所示：

int a = 1;
while (a != 1) {
    System.out.println(a);
}

上述的while循环根本不会执行,由于do while循环是循环一次在判断，因此无法替换，所以B错误

C：没有找到可以反对的例子，所以C正确

D：do while循环不过是先执行在判断，while循环完全可以做到，来一个do while循环的特例吧，如下所示：

int a = 1;
do{
    System.out.println(1);
} while (a!=1);

上述例子中只会执行一次循环体，接下来看我用while循环怎么替代它，如下所示：

int a = 1;
while(a!=2){
    System.out.println(1);
    a++;
}

虽然样子不一样，但是实现的功能是一样的，都是一次循环，所以D正确

E：既然while循环都能替代do while循环，那for循环和while循环可以相互转换，所以for循环也能替代do while循环，所以E正确