Java的循环结构

三种循环结构

任何复杂的程序逻辑，都可以通过三种结构来实现：

顺序结构：从上往下逐行执行，每句必走

分支结构：有条件的执行某语句一次，并非每句必走

循环结构：有条件的执行某语句多次，并非每句必走

循环：反复多次执行一段相同或相似的代码

循环三要素：

• 循环变量的初始化
• 循环的条件(以循环变量为基础)
• 循环变量的改变(向着循环的结束变)
  • 循环变量：在整个循环过程中所反复改变的那个数

案例一：
   输出5次"行动是成功的阶梯"
   	行动是成功的阶梯
   	行动是成功的阶梯
   	行动是成功的阶梯
   	行动是成功的阶梯
   	行动是成功的阶梯
   循环变量:次数times
   1)int times=0;
   2)times<5
   3)times++;
   	times=0/1/2/3/4/ 5时结束

案例二：
   输出9的乘法表:
   	1*9=9
   	2*9=18
   	3*9=27
   	4*9=36
   	5*9=45
   	6*9=54
   	7*9=63
   	8*9=72
   	9*9=81
   循环变量:因数num
   1)int num=1;
   2)num<=9
   3)num++;
   	num=1/2/3/4/5/6/7/8/9/ 10时结束

   	1*9=9
   	3*9=27
   	5*9=45
   	7*9=63
   	9*9=81
   循环变量:因数num
   1)int num=1;
   2)num<=9
   3)num+=2;
   	num=1/3/5/7/9/ 11时结束		

1. while循环结构

• while结构：先判断后执行，有可能一次都不执行

1)语法:
		while(boolean){
			语句块/循环体------------反复执行的代码
		}
2)执行过程:
先判断boolean的值，若为true则执行语句块，
再判断boolean的值，若为true则再执行语句块，
再判断boolean的值，若为true则再执行语句块，
如此反复，直到boolean的值为false时，while循环结束

//1.输出5次"行动是成功的阶梯":
int times = 0; //1)循环变量的初始化
while(times<5){ //2)循环的条件
	System.out.println("行动是成功的阶梯");
	times++; //3)循环变量的改变
}
System.out.println("继续执行...");
/*
	执行过程:----带数
					times=0
	true	输出	times=1
	true	输出	times=2
	true	输出	times=3
	true	输出	times=4
	true	输出	times=5
	false 	while循环结束
	输出继续执行...
*/

//2)输出9的乘法表:
int num = 1; 	//3*9=27
while(num<=9){
	System.out.println(num+"*9="+num*9);
	num+=2; 	//num++;
}
System.out.println("继续执行...");

2. do…while结构：先执行后判断，至少执行一次

• 如何选择：第1要素与第3要素的代码相同，首选do…while

1)语法:
		do{
			语句块-------------------反复执行的代码
		}while(boolean);
2)执行过程:
		先执行语句块，再判断boolean的值，若为true则
		再执行语句块，再判断boolean的值，若为true则
		再执行语句块，如此反复，直到boolean的值为false时，循环结束

package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
		System.out.println(num); //作弊
		
		//假设num=250
		//300(大),200(小),250(对)
		int guess;
		do{
			System.out.println("猜吧!");
			guess = scan.nextInt(); //1+3
			if(guess>num){
				System.out.println("太大了");
			}else if(guess<num){
				System.out.println("太小了");
			}else{
				System.out.println("恭喜你猜对了!");
			}
		}while(guess!=num); //2
	}
}

3. for结构：应用率高、与次数相关的循环

1)语法:
	//  1  2  3
	for(要素1;要素2;要素3){
		语句块/循环体--------------反复执行的代码 4
	}
2)执行过程:
	1243243243243243...2

for(int times=0;times<5;times++){
	System.out.println("行动是成功的阶梯");
}
System.out.println("继续执行...");

//for中的循环变量num的作用域，仅在当前for中-----特殊的单独记
for(int num=1;num<=9;num++){ //1到9
	System.out.println(num+"*9="+num*9);
}

for(int num=1;num<=9;num+=2){ //1/3/5/7/9
	System.out.println(num+"*9="+num*9);
}

for(int num=9;num>=1;num--){ //9到1
	System.out.println(num+"*9="+num*9);
}

/*
	执行过程:----带数
		num=9 true 9*9=81
		num=8 true 8*9=72
		num=7 true 7*9=63
		num=6 true 6*9=54
		num=5 true 5*9=45
		num=4 true 4*9=36
		num=3 true 3*9=27
		num=2 true 2*9=18
		num=1 true 1*9=9
		num=0 false for循环结束
*/

//for的特殊格式:
int num=1;
for(;num<=9;num++){
	System.out.println(num+"*9="+num*9);
}

for(int num=1;num<=9;){ //1到9
	System.out.println(num+"*9="+num*9);
	num++;
}

for(;;){ //没有条件的循环，就是一个死循环
	System.out.println("我要学习...");
}

for(int i=1,j=5;i<=5;i+=2,j-=2){
}
/*
	i=1,j=5
	i=3,j=3
	i=5,j=1
	i=7,j=-1
*/	

4. 三种循环结构如何选择：

• 先看循环是否与次数有关：
  • 若有关-------------------------------直接上for
  • 若无关，再看第1要素与第3要素代码是否相同：
    • 若相同-------------------------直接上do…while
    • 若不同-------------------------直接上while

5. break：跳出循环

for(int num=1;num<=9;num++){
	if(num==5){ //在某种特定条件下，提前结束循环
		break; //跳出循环
	}
	System.out.println(num+"*9="+num*9);
}
/*
	num=1 1*9=9
	num=2 2*9=18
	num=3 3*9=27
	num=4 4*9=36
	num=5
*/	

6. continue：跳过循环体中剩余语句而进入下一次循

//输出9的乘法表，跳过能被3整除的
for(int num=1;num<=9;num++){
	if(num%3==0){
		continue; //跳过循环体中剩余语句而进入下一次循环
	}
	System.out.println(num+"*9="+num*9);
}
/*
	num=1 1*9=9
	num=2 2*9=18
	num=3
	num=4 4*9=36
	num=5 5*9=45
	num=6
	num=7 7*9=63
	num=8 8*9=72
	num=9
	num=10 false
*/

//输出9的乘法表，只要不能被3整除的
for(int num=1;num<=9;num++){
	if(num%3!=0){
		System.out.println(num+"*9="+num*9);
	}
}

7. 嵌套循环：

• 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
• 执行规则：外层循环走一次，内层循环走所有次
• 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
• break常规只能跳出当前一层循环

//乘法表格
for(int num=1;num<=9;num++){ //控制行
	for(int i=1;i<=num;i++){ //控制列
		System.out.print(i+"*"+num+"="+i*num+"\t");
	}
	System.out.println(); //换行
}
/*
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
*/
/*
	执行过程:-----带数
	num=3
		i=1 1*3=3
		i=2 2*3=6
		i=3 3*3=9
		i=4 false
		换行
	num=2
		i=1 1*2=2
		i=2 2*2=4
		i=3 false
		换行
	num=1
		i=1 1*1=1
		i=2 false
		换行	
*/