Java菜鸟学习之路之基础编程---for循环、while循环、do - while、嵌套循环与循环关键字break和continue详解(五)

1.循环结构


1.1 定义:在某些条件满足的情况下,反复执行特定代码的功能


1.2 分类:

        for循环

        while循环

        do - while循环


1.3 循环语句的四个组成部分(要素):

        (1)初始化部分

        (2)循环条件部分 --->是boolean类型得条件表达式

        (3)循环体部分

        (4)迭代部分

 

1.4 执行顺序:

        (1)初始化部分(只执行一次,进入循环条件,对变量的初始值进行定义)

        (2)循环条件部分(可多次进行判断,直到条件不再满足的情况下就跳出循环,接着执行接下来的顺序执行语句)

        (3)循环体部分(进行循环体内部多次反复执行的语句)

        (4)迭代部分(对初始化的部分进行迭代,可以理解为为初始化条件多次进行改变,改变之后判断循环条件是否满足,满足则继续执行,不满足就跳出循环,接着循序执行之后的代码)

 

2.for循环


2.1 格式:

for((1)初始化条件;(2)循环条件;(3)迭代条件){
                (4)循环体;

}
 

2.2 执行顺序:

                [ (1)-(2)-(4)-(3) ]、[ (2-(4)-(3) ]、[ (2)-(4)-(3) ] (2、4、3不断重复执行)、(2),直到最后累加的迭代条件不在满足循环条件的时候则跳出循环


for循环得测试用例:

public class For_Test {
	public static void main(String[] args) {
		//输出6遍Hello World;
		/*需要执行重复功能的代码块的时候,这样显然搞得代码很冗余,所以再java中引入了循环结构
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		*/
		for(int i = 0;i <= 5;i++) {		//此处的初始化条件定义一个int整型变量i,是局部变量,在主函数中只能定义一个同名变量
			System.out.println("Hello World!");		//功能性重复,反复要执行的代码
		}
		//System.out.println(i);	编译出错,局部变量i只在for循环内有效,出了for循环就不能调用了
		
		//练习1
		int num = 1;
		for(System.out.println('a');num <= 3;System.out.println('c'),num++) {
			System.out.println('b');
		}
		//输出结果:abcbcbc
		//初始化条件为:int num = 1,输出'a',只执行一次
		//判断循环继续条件num <= 3;
		//执行语句:输出'b',输出3次
		//迭代条件:输出'c',并进行初始化变量的迭代,执行3次
		
		//例题:遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
		int sum = 0;	//记录累加和
		int count = 0;	//记录偶数的个数
		for(int i = 1;i <= 100;i++) {
			if(i % 2 == 0) {
				sum += i;
				count++;
				System.out.println(i);
			}
		}
		System.out.println("总和为:"+sum);
		System.out.println("偶数的个数为:"+count);
	}
}

 

例:12和20的最大公约数是4,最小公倍数是60

最大公约数:(1)首先找一个数能被两数都整除,那么这个数就是两数的公约数

                   (2)思路一:最大肯定可以找到最小数的范围之内,定义一个循环,从1开始最大到两数中的最小数去寻找,找到一个就将这个数赋值给gys,找到下一个大的公约数,则覆盖较小公约数,直到跳出循环,最终赋值的公约数就是最大公约数

                       思路二:从两数中的最小数开始向下遍历,一旦两数都能同时把这个数除尽,那么毫无疑问,那么肯定就是最大的公约数,因为是从大到小开始遍历的

 

最小公倍数:(1)首先找一个数能把两个数都整除,那么这个数肯定就是两数的公倍数

                   (2)最小公倍数肯定最小也得大于两数中得最大数,我们这样想,从两数中得较大数来开始遍历,遍历最大大不到两者得乘积,一直递增进行操作,一旦找到一个数可以直接将两数都整除,肯定就可以确定该数就是最小得公倍数了,就可以跳出循环,否则继续进行迭代

求两数最大公约数和最小公倍数得测试用例:

public class XunHuan1_Test {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入第一个正整数:");
		int num1 = scan.nextInt();
		System.out.println("请输入第二个正整数:");
		int num2 = scan.nextInt();
		int gys = 0;
		int min = num1 < num2?num1 : num2;	//获取两数的较小数
		int max = num1 > num2?num1 : num2;	//获取两数的较大数
		/*for(int i = 1;i <= min;i++) {
			if(num1 % i ==0 && num2 % i == 0) {
				gys = i;
			}
		}
		System.out.println("两数的最大公约数为: "+gys);
		*/
		for(int i = min;i >= 1;i--) {
			if(num1 % i ==0 && num2 % i == 0) {
				System.out.println("最大公约数为: "+i);	//输出最大公约数
				break;	//跳出当前循环语句,不在执行循环结构,若无break语句,那么每个公约数都会进行输出
			}
		}
		int j = max;
		for(;j <= max * min;j++) {
			if(j % num1 ==0 && j % num2 == 0) {
				System.out.println("两数的最小公倍数为"+j);
				break;
			}
		}
	}
}

 

说明:break关键字的使用:

        一旦在循环执行break语句,那么就直接跳出当前循环,循环语句不在进行执行

 

3.while结构


3.1循环语句的四个组成部分(要素):

        (1)初始化部分

        (2)循环条件部分 --->是boolean类型

        (3)循环体部分

        (4)迭代部分


3.2while循环得结构:

       (1)

       while( (2) ){

              (3);

              (4);

       }

注意:执行顺序和for循环相同:[ (1)-(2)-(4)-(3) ]、[ (2)-(4)-(3) ]、[ (2)-(4)-(3) ] (2、4、3不断重复执行)、(2),直到最后累加的迭代条件不再满足循环条件的时候则跳出循环 

 

3.3说明:

        1.写while循环千万不能忘记写迭代得条件,否则会一个变量值无法进行迭代,反复执行执行条件,没有跳出条件,造成死循环!

        2.我们写程序,要避免死循环。

        3.for循环和while循环是可以相互转换得!

        4.for循环和while循环得初始化条件不同

注意:for循环条件内定义得变量i只能在for循环之内有效调用,while循环初始化条件定义在外部,初始化条件变量也可以进行调用,在一整个函数之内有效调用。

while循环的测试用例:

public class While_Test {
	public static void main(String[] args) {
		//遍历100以内得所有偶数
		int i = 1;
		while(i <= 100) {
			if(i % 2 == 0) {
				System.out.println(i);
			}
			i++;
		}
		//最后输出得一个偶数为100,执行语句执行完之后,继续进行迭代操作,此时i值已经变成了101,不满足循环继续条件,跳出循环
		System.out.println(i); 		//101
	}
}

 

4.do - while循环


4.1循环语句的四个组成部分(要素): 

        (1)初始化部分

        (2)循环条件部分 --->是boolean类型

        (3)循环体部分

        (4)迭代部分

 

4.2结构:

        (1)

        do{

                (3)

                (4)

        }while( (2) );

执行过程:(1) - (3) - (4) - (2) - (3) - (4) - ... - (2)

 

4.3说明:

        (1)do - while循环至少会执行一次循环体!(不管三七二十一,进去先执行一次循环体,之后在进行判断条件是否满足循环条件)

        (2)开发中,大多使用for循环和while循环进行循环语句的执行,较少使用do - while语句

do - while循环的测试用例:

public class DoWhIle_Test {
	public static void main(String[] args) {
		//输出100以内的偶数
		int num = 1;
		do {
			if(num % 2 == 0) {
				System.out.println(num);
			}
			num++;
		}while(num <= 100);
		
		
		//-----------------------do - while循环语句至少执行一次-----------------------------------
		int num2 = 18;
		do {
			System.out.println(num2);		//18,会进行一次输出
			num2++;
		}while(num2 > 20);		//判断条件不满足,无法继续执行循环语句
	}
}

 

while(true)无限循环,用户自定义判出条件的测试用例: 

/*题目:*
 * 从键盘读入个数不确定的整数,并判断读入的正数和负数的个数,输入为0时,程序结束 
 * 
 **/
import java.util.Scanner;
public class ForWhile_Test {
	public static void main(String[] args) {
		int positiveNumber = 0;		//记录正数的个数
		int negativeNumber = 0;		//记录负数的个数
		Scanner scan = new Scanner(System.in);
			while(true) {		//等价于for(;;) {,意味着没有任何初始化条件,循环条件直接进入,无限循环执行,判出条件为用户自定义
			System.out.print("请输入你想输入的数据:  ");
			int number = scan.nextInt();
			//判断正负数情况
			if(number > 0) {
				positiveNumber++;
			}else if(number < 0) {
				negativeNumber++;
			}else {
				break;	//一旦执行break,那么就跳出循环
			}
		}
		System.out.println("负数个数为 " + negativeNumber +"个\n" + "正数个数为 "+ positiveNumber +"个");
	}
}

说明:

       1.不在循环条件部分限制次数的结构:for(;;)或while(true)

       2.结束循环有几种方式?

              (1)方式一:循环部分返回false

              (2)方式二:在循环体中,执行break

 

5.嵌套循环


5.1使用:

      1.嵌套循环:将一个循环结构A声明在另一个循环结构B的循环体中

      2.外层循环:循环结构B,控制内部整体循环结构执行的次数(轮数),内层整体的循环结构相当于外层循环的一次循环体的执行语句

         内层循环:循环结构A,内层循环控制个数,控制内部循环执行语句的执行次数


5.2说明:

        (1)内存循环结构遍历一次,只相当于外层循环执行了一次

        (2)假设外层循环需要执行m次,内存循环需要执行n次。此时内层循环的循环体一种执行了:m * n次

 

5.3使用技巧:

        外层循环控制行数,内层循环控制列数

 

嵌套循环的测试用例:

public class QianTao_Test {
	public static void main(String[] args) {
		//输出******
		for(int i = 1;i <= 6;i++) {
			System.out.print('*');
		}
		System.out.println();
		/*输出:
		 *		******
		 * 		******
		 * 		******
		 * 		******
		 *	 	******
		 * */
		for(int i = 0;i <= 4;i++) {		//外层循环控制行数,控制内部整体循环结构执行的次数,内层整体的循环结构相当于外层循环的一次循环体的执行语句
			for(int j = 1;j <= 6;j++) {		//内层循环控制个数,控制内部循环执行语句的执行次数
				System.out.print('*');
			}
			System.out.println();
		}
		
		/*输出:			i(打印的行号)			j(*的个数)
		 * 		*		1			1		
		 * 		**		2			2
		 * 		***		3			3
		 * 		****		4			4
		 * 		*****		5			5
		 * */
		for(int i = 1;i <= 5;i++) {		//控制行数
			for(int j = 1;j <= i;j++) {		//控制列数,因为每列的*个数都是变化的,所以也就需要找变化的变量来和它进行匹配,那么外层循环变量i是最好的选择
				System.out.print('*');
			}
			System.out.println();
		}
		

		/*输出:				i(打印的行号)	j(*的个数)	
	         规律:i + j = 6,那么*的个数j = 6 - i
		 
                 * 		*****		1		5
		 * 		****		2		4	
		 * 		***		3 		3
		 * 		**		4		2
		 * 		*		5		1			
		 * */
		 for(int i = 1;i <=  5;i++) {
			 for(int j = 1;j <= 6 -i;j++) {
				 System.out.print("*");
			 }
			 System.out.println();
		 }
    }
}

 

嵌套循环的测试用例一:九九乘法表

//嵌套循环应用一:九九乘法表
public class NineNine_Test {
	public static void main(String[] args) {
		for(int i = 1;i <= 9;i++) {    //外层循环控制行数
			for(int j = 1;j <= i;j++) {     //内层循环控制列数
				System.out.print(i + "*" + j + "= "+ i * j + "\t");
			}
                        //打印完一整行,进行换行操作
			System.out.println();
		}
	}
}

 

嵌套循环的测试用例二:100以内的质数

/*
输出100以内的所有的质数(只能被1和它本身整除的自然数就是质数,素数)
质数(素数):只能被1和它本身整除的自然数。--->从2开始到这个数-1结束为止,都不能被这个数整除为止

最小的质数:2
*/
public class PrimeNumber_Test {
	
	public static void main(String[] args) {
		//方式一:
		long start = System.currentTimeMillis();
		//计算当前时间距1970年01月01日00时00分00秒的毫秒数,返回的是一个long类型的数值,程序开始执行时得毫秒数
		for(int i = 2;i <= 100;i++) {	//除数
			
                    int sumNum = 1;		//统计该数的约数,计数器
			
                    for(int j = 2;j < i;j++) {		//被除数,不计算1和它本身
				if(i % j == 0) {
					sumNum++;
				}
		    }
            
		    if(sumNum == 1) {	//计数器不变,代表没有其它的约数了
			    System.out.println(i);	//输出该质数
	            }
            
		}
        
		long end = System.currentTimeMillis();	//程序执行结束之后返回得毫秒数
		System.out.println("所花费得时间为: "+ (end - start));	//计算整体找质数程序得运行时长

 

嵌套循环的测试用例二得优化:100以内的质数

//优化方式二:
		long start1 = System.currentTimeMillis();
		
		boolean isFlag = true;		//将表征符号定义在外部节省空间,不要每次都创建一个新变量(内存空间)
		for(int i = 2;i <= 100;i++) {	//除数
			
                        //优化二:对本身是非质数得自然数是有效得
			for(int j = 2;j <= Math.sqrt(i);j++) {		//被除数,不计算1和它本身,							
				
				if(i % j == 0) {
					isFlag = false;
					break;		//优化一:只对本身是非质数的自然数是有效的,因为只有非质数自然数才能进入此判断条件		
							//只要有一个新的约数,那它必然就不是一个质数了,之后的被除数的情况也不需要考虑了,直接break跳出内层循环,开启外层新一个自然数的循环
				}
				
			}
			
			if(isFlag == true) {	//表征符号不变,没有其它的约数了
				System.out.println(i);	//输出该质数
			}
			
			isFlag = true;	//每一个自然数(除数),内层判断完之后,要对外部自然数表征符号isFlag进行重置,否则会出现输出不足的情况
		}
		
		long end1 = System.currentTimeMillis();
		System.out.println("所花费得时间为: "+ (end1 - start1));
	}
}

说明:由于过小得数据量无法体现两执行程序得具体执行效率差距,所以我们将其中得数据量从100改成了100000,未优化得方法寻找质数总时长为12906ms,优化之后得方法寻找质数总时长为91ms,可以看出两算法之间明显得差距,未优化代码和优化之后得代码得执行效率几乎是几何倍增长,所以代码不在于代码量得大小,而在于其执行效率 

 

6.循环语句中得关键字break和continue解析


  • break关键字得适用范围:                      循环中使用得作用(不同点)         相同点

       switch - case语句

       循环结构中                                           结束当前循环                             关键字后面不能声明执行语句

  • continue关键字得适用范围:

       循环结构中                                           结束当次循环                             关键字后面不能声明执行语句

 

break - continue测试用例:

public class BreakContinue_Test {
	public static void main(String[] args) {
		for(int i = 1;i <= 10;i++) {
			if(i % 4 == 0) {
				//break;		//一旦循环语句中执行到break语句,那么立即跳出当前循环体结构
				continue;		//一旦执行到continue语句,那么就跳过这次循环体得执行,continue后面得语句也不执行了,开启下次循环
				//System.out.println("我是最强得!");		编译出错,无法访问得语句,在同一个作用范围内,两关键字后面都不能带执行语句
			}
			System.out.println(i);  	//break输出:1 2 3
										//continue输出:1 2 3 5 6 7 9 10
		}
		System.out.println("\n ");
		
		//-----------------------------------------
		label:for (int i = 1; i <= 4; i++) {	//对外层循环指定标签
			
			for(int j = 1;j <= 10;j++) {
				if(j % 4 == 0) {
					
					//break label;		//跳出指定标签结构得循环
					continue label;		//跳出指定标识得当次循环结构,开启其下一次循环结构
					//break;			//默认跳出包裹此关键字最近得一层循环,
					//continue;			//跳出包裹此关键字内层得此次循环,开启内层下次循环
					
				}
				System.out.print(j);
			}
			System.out.println();
		}
	}
}

 

 

 

 

 

你可能感兴趣的:(java基础,菜鸟学习初体验,java,java,eclipse)