Java基础3--循环结构

概念

去执行重复的代码

循环的分类

1. while循环

* 语法：

	    while(判断条件){
			功能语句;
		}
* 判断条件：

	`布尔类型的值或者表达式`
* 执行流程：
	1. 判断条件是否成立，如果成立执行功能语句
	2. 执行完成后再次判断条件是否成立，如果成立继续执行功能语句，直到条件不成立跳出循环。

/**
 * 
 * @author Administrator
 *	while循环
 *	while(条件){
 *		功能语句;
 *	}
 *	判断条件：布尔类型的值或者表达式
 *	执行流程：先判断while中条件，如果条件为true，则执行功能语句，如果条件为false，则跳出循环
 *	注意：在循环时一般都要给循环跳出条件，否则循环会一直执行变成死循环将永远不会跳出循环
 */
public class WhileDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a=10;
		int sum=0;
		while(a>0) {
			System.out.println("第"+(a-9)+"次循环");
			System.out.println("a="+a);
			sum+=a;
			System.out.println("sum="+sum);
			a--;
		}
		//打印1到10之间的偶数
		int x=1;
		while(x<=10){
			if(x%2==0) {
				System.out.println(x);
			}
			x++;
		}
		//特殊while的写法
		
		/*while(false) {   //没有实际意义
			System.out.println();
		}*/
		//while(true);  
	}
}

2. do while循环

* 语法：
		    do{
				功能语句；
			}while(判断条件);

* 判断条件：
	布尔类型的值或者表达式
* 执行流程：
	1. 先执行do中的功能语句，
	2. 判断while中的条件是否成立如果成立继续执行do中的功能语句
	3. 直到while中的条件不成立跳出循环

/**
 * @author Administrator
 *	do-while循环
 *	do{
 *		功能语句;
 *	}while(条件);
 *	循环条件：布尔类型的值或者表达式
 *	执行流程：先执行do中的功能语句，然后判断while中的条件，知道while中的条件为false，跳出循环语句
 *	注意：如果条件表达式的值一直为true，没有控制好条件变量，则会出现死循环情况
 *		do-while循环中功能语句至少都会被执行一次
 */
public class Do_whileDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * 	统计10以内2的倍数和个数
		 */
		int count=0;   //计数变量   计算2的倍数的个数
		int i=1;
		do {
			if(i%2==0)  //对2取模等于0的话就是2的倍数
			{
				System.out.println("i="+i);
				count++;
			}
			i++;
		}while(i<=10);
		while(i<=10){
			if(i%2==0)  //对2取模等于0的话就是2的倍数
			{
				System.out.println("i="+i);
				count++;
			}
			i++;
		}
		System.out.println("count="+count);  //打印2的倍数的个数
		/*
		 * 	求出1-10所有偶数的和
		 * 	遍历1-10之间的数字
		 * 	判断是否是偶数
		 * 	将偶数求和
		 */
		int sum=0;  //定义变量存储所求的和
		int j=1;
		do {
			if(j%2==0) {  //遍历是否为偶数
				sum+=j;  //偶数相加赋值给sum
			}
			j++;
		}while (j<=10);
		System.out.println("sum="+sum);
		/*
		 * 
		 * 	求出10以内所有奇数的乘积
		 */
		int k=0;
		int s=1;
		do {
			if(k%2!=0) {
				s*=k;  //3*5*7*9   105*9   945
			}
			k++;
		}while(k<=10);
		System.out.println("s="+s);
	}

}

3. for循环

* 语法：

	    for(初始化A;判断条件B;循环后语句C){
 			功能语句D;
 		}
* 初始化A:定义一个初始变量
* 判断条件B:用来控制是否进行循环
* 循环后语句C:如果进入循环，执行功能语句D,然后执行语句C
* 功能语句D:需要完成的功能
* 执行流程:

		第一次: A-->B-->D-->C
		第二次: B-->D-->C
		、、、、
		第N次: B为false结束循环

/**
 * 
 * @author Administrator
 *	for循环
 *	语法：
 *	for(初始化A;判断条件B;循环后语句C){
 *		功能语句D;
 *	}
 *	初始化A:定义一个初始变量
 *	判断条件B:用来控制是否进行循环
 *	循环后语句C:如果进入循环，执行功能语句D,然后执行语句C
 *
 *	功能语句D:需要完成的功能
 *	执行流程:
 *	第一次: A-->B-->D-->C
 *	第二次: B-->D-->C
 *	、、、、
 *	第N次: B为false结束循环

 */
public class ForDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//使用for循环打印1到10之间的数字
		for (int i = 1; i < 11; i++) {  //i的作用域只在for循环内部
			System.out.println(i);
		}
		int j;//此时的j的作用范围是整个方法内部
		for(j=1;j<11;j++) {
			System.out.println(j);
		}
		//for的死循环
		for(;;) {
			System.out.println("这是for的死循环");
		}
	}
}

/**
 * 
 * @author Administrator
 *	for循环
 *	语法：
 *	for(初始化A;判断条件B;循环后语句C){
 *		功能语句D;
 *	}
 *	初始化A:定义一个初始变量
 *	判断条件B:用来控制是否进行循环
 *	循环后语句C:如果进入循环，执行功能语句D,然后执行语句C
 *
 *	功能语句D:需要完成的功能
 *	执行流程:
 *	第一次: A-->B-->D-->C
 *	第二次: B-->D-->C
 *	、、、、
 *	第N次: B为false结束循环

 */
public class ForDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//使用for循环计算1-10的乘积
		int s=1;
		for (int i = 1; i < 11; i++) {  //i的作用域只在for循环内部
			s*=i;
		}
		System.out.println(s);
		/*i
		 * 2.以下两个示例中 最后i的值是多少 判断执行了几次 循环几次 代码的最终的输出结果是多少？
		 *  (1) for(int i = 1;i<=10;i+=2){
		 * 		System.out.println("i="+i);      
		 *	 } 
		 *	答 ：最后i的值为：11     判断执行了6次。循环了5次，   输出结果为：i=1    i=3  i=5   i=7  i=9 
		 *	 （2） for(int j = 1;j++<=10;j+=2){
		 * 		System.out.println("j="+j); 
		 * 	}
		 * 	答 ：最后i的值为：14     判断执行了5次。循环了4次，   输出结果为：j=2    j=5  j=8  j=11  
		 */
		for(int j = 1;j++<=10;j+=2){
			 System.out.println("j="+j); 
		}
	}

}

4. 嵌套循环

在一个循环中嵌套循环，在嵌套循环时最好不要嵌套太多，因为嵌套循环太多容易损耗效率

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

public class QTForDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//打印五排*，每排有五颗
		//每次只打印一个*
		for (int i = 0; i < 6; i++) {
			for (int j = 0; j < 6; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
		/*
		 *         1
		 *       1    1
		 *     1   2    1
		 *   1   3    3    1
		 *   .......
		 */
		//定义一个二维数组保存数值
		int[][] arr=new int[6][6];
		//使用两层for循环来计算每层中的数字     
		for (int i = 0; i < 6; i++) {
			for (int j = 0; j <= i; j++) {
				//每层第一个数字和最后一个数字赋值为1
				if(j==0||j==i) {
					arr[i][j]=1;
				}else {  //不是第一个数字和最后一个数字的值例如第j个数字的值等于上一层中第j-1个数字与第j个数字的和
					arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
				}
			}
		}
		//按照正三角型的格式把数字和空格结合打印出来
		for (int i = 0; i < 6; i++) {
			//打印前面的空格
			for (int j = 0; j < 6-i; j++) {
				System.out.print("  ");
			}
			//打印数字
			for (int j = 0; j <= i; j++) {
				System.out.print(arr[i][j]+"   ");
			}
			System.out.println();    //打印换行
			
		}
	}

}

5. 循环控制语句

* break：跳出当前循环，后面的循环将不会再被执行
* continue：终止本次循环，在本次循环中不执行continue以后的代码，直接跳到下次循环开始
* return：终止当前方法，遇到return语句后，程序将会直接跳出当前方法，在当前方法中在return语句后的代码将都不会再被执行。

/**
 * 
 * @author Administrator
 *	循环控制语句：用来提前终止循环或者跳出循环
 *  break：终止当前循环后面的循环不会再执行
 *  continue：结束本次循环，直接跳转到下一个循环
 *  return：终止当前方法，后面的循环不会再执行，并且方法中的其他代码也不会执行 
 */
public class CircleControlDemo {

	public static void main(String[] args) {
		// break跳出当前循环
		//打印1-8的值，当i等于6的时候， 结束循环， 不打印 7 8， 只打印1 2 3 4 5 6  
		for (int i = 1; i < 9; i++) {
			System.out.println(i);
			if(i==6) {
				break;
			}
		}
		//continue 跳出当前循环
		//打印1-8的值，当i等于6的时候，跳出本次循环， 不打印 6， 只打印1 2 3 4 5 7  8
		for (int i = 1; i < 9; i++) {
			if(i==6) {
				continue;
			}
			System.out.println(i);
		}
		//return 跳出当前方法
		//打印1-8的值，当i等于6的时候，跳出main方法， 不打印 6，7，8， 只打印1 2 3 4 5
		for (int i = 1; i < 9; i++) {
			if(i==6) {
				return;
			}
			System.out.println(i);
		}
	}
}