尚硅谷java学习笔记第四天（循环结构）

最新推荐文章于 2024-11-04 22:26:34 发布

m0_62654303

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量172

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_62654303/article/details/120774021

版权

3：循环结构

根据循环条件，重复性的执行某段代码。

有while、do…while、for三种循环语句。

注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

在这里插入图片描述

循环语句的四个组成部分

初始化部分(init_statement)

循环条件部分(test_exp)

循环体部分(body_statement)

迭代部分(alter_statement)

for循环

/*
For循环结构的使用
一，循环结构的四个要素
1.初始化条件
2.循环条件
3.循环体
4.迭代条件

二，for循环的结构

for(1;2;4){
	3
}

执行过程：1 - 2 - 3 - 4 - 2 - 3 - 4....- 2


说明：
②循环条件部分为boolean类型表达式，当值为false时，退出循环
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
④可以有多个变量更新，用逗号分隔
*/
class ForTest{
	public static void main(String[] args) {
		//输出5个Hello World!
		for(int i = 1;i <= 5;i++){
		
		System.out.println("Hello World!");
		
		}

		//练习
		int num = 1;
		for(System.out.println("a");num <= 3;System.out.println("c"),num++){
			
			System.out.println("b");
		}
		//输出结果 abcbcbc

		//例题：遍历100以内的偶数
		int sum = 0;//100以内偶数的和
		int count = 0;//100以内偶数的个数
		for(int i = 1;i <= 100;i++){
			
			if(i%2 == 0){
				
				System.out.println(i);
				sum += i;
				count++;
			}		
		}
		System.out.println("100以内偶数的和为：" + sum);
		System.out.println("100以内偶数的个数为：" + count);

	}
}

/*
for语句例题1
编写程序从1循环到150，并在每行打印一个值
在每个3的倍数行上打印出“foo”
在每个5的倍数行上打印“biz”
在每个7的倍数行上打印输出“baz”
*/

class ForTest{
	public static void main(String[] args) {
		
		for(int i = 1;i <= 150;i++){
			
			System.out.print(i + " ");
			
			if(i%3 == 0){	
				System.out.print(" foo");				
			}
			if(i%5 == 0){	
				System.out.print(" biz");				
			}
			if(i%7 == 0){	
				System.out.print(" baz");				
			}
			System.out.println();
		}
	}
}

/*
for语句例题2
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用
*/
import java.util.Scanner;

class ForTest{
	
	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 min = (num1 <= num2)? num1: num2;
		//利用for反向遍历
		for(int i = min;i >= 1;i--){

			if(num1%i == 0 && num2%i == 0){	
				System.out.println("两个数的最大公约数为：" + i);
				break;	//终止程序
			}	
		}
		//先取出两个数的较大值
		int max = (num1 >= num2)? num1: num2;
		//利用for正向遍历
		for(int i = max;i <= num1 * num2;i++){
			
			if(i%num1 == 0 && i%num2 == 0){	
				System.out.println("两个数的最小公倍数为：" + i);
				break;//终止程序
			}			
		}
	}
}

/*
 * 3.输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数
	字立方和等于其本身。
	例如： 153 = 1*1*1 + 3*3*3 + 5*5*5
 * 
 */
public class IfTest2 {
	public static void main(String[] args) {
				
		for(int i = 99;i <= 999;i++){
			
			int bai = i/100;
			int shi = i%100/10;
			int ge = i%10;
						
			if(i == bai * bai * bai + shi * shi * shi + ge * ge * ge){
				
				System.out.println(i);	//153 370 371 407			
			}			
		}				
	}
}

while循环

在这里插入图片描述

/*while 循环的使用
 * 
 * 一.循环结构的4个要素
 * 1.初始化条件
 * 2.循环条件  -- 是boolean类型
 * 3.循环体
 * 4.迭代条件
 * 
 * 二.while循环的结构
 * 
 * 1
 * while(2){
 * 		3;
 * 		4;
 * }
 * 
 * 执行过程：1 - 2 - 3 - 4 - 2 - 3 - 4... - 2
 * 说明；
 * 1，写while循环千万不要丢了迭代条件，一旦丢了，就可能导致死循环。
 * 2，我们写程序，要避免死循环，
 * 3,for循环和while循环是可以相互转换的
 * 	区别：for循环和while循环的初始化条件部分的作用范围不同。
 */
public class WhileTest {
	public static void main(String[] args) {
				
			//遍历100以内的偶数
			int i = 1;
			
			while(i <= 100){
				
				if(i % 2 == 0){
					
					System.out.println(i);	
				}
				i++;
			}
        	//出了while循环以后，仍然可以调用。
       		 System.out.println(i);
	}
}

do-while

/*while 循环的使用
 * 
 * 一.循环结构的4个要素
 * 1.初始化条件
 * 2.循环条件  -- 是boolean类型
 * 3.循环体
 * 4.迭代条件
 * 
 * 二.do-while循环的结构
 * 1
 * do{
 * 		3;
 * 		4;
 * }while(2);
 * 
 * 
 * 
 * 执行过程：1 - 3 - 4 - 2 - 3 - 4 - 2 - 3 - 4... - 2
 * 说明；
 * 1，do-while至少会执行一次循环体。
 * 2，开发中，使用for和while更多，较少使用do-while
 * 
 */
public class WhileTest {
	public static void main(String[] args) {
				
			//遍历100以内的偶数
			int i = 1;
			int sum = 0;
			int count = 0;
			
			do{
				if(i % 2 == 0){
					
				System.out.println(i);
				
				sum += i;
				
				count++;
				
				}
				
				i++;
			
			}while(i <= 100);
								
			System.out.println(sum);
			System.out.println(count);
        
			int num1 = 10;
			while(num1 > 10){
				System.out.println("while");
				num1--;
			}
			//do-while至少执行一次循环体
			int num2 = 10;
			do{
				System.out.println("do-while");
				num1--;
			}while(num1 > 10);				
	}
}

/*while 循环的使用
 *从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
 *说明：
 *1.不在循环条件部分限制次数的结构：for(;;)或while(true)
 *2.结束循环有几种方式？
 *	方式一：循环条件部分返回false；	
 *	方式二：在循环体中，执行break；
 */
import java.util.Scanner;
public class WhileTest {
	public static void main(String[] args) {
		
			Scanner scan = new Scanner(System.in);
				
			System.out.println("请输入整数：");
				
			int positiveNumber = 0;
			int negativeNumber = 0;
			
			for(;;){//while(true){
				int num = scan.nextInt();
				if(num > 0){
					positiveNumber++;
				}
				if(num < 0){
					negativeNumber++;
				}
				if(num == 0){					
					break;				
				}
			}
			System.out.println("正数的个数为：" + positiveNumber);
			System.out.println("负数的个数为：" + negativeNumber);			
	}
}

嵌套循环

将一个循环放在另一个循环体内，就形成了嵌套循环。其中， for ,while ,do…while均可以作为外层循环或内层循环。

实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

/*
 * 嵌套循环的使用
 * 1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环
 * 
 * 2.
 * 外层循环：循环循环B
 * 内层循环：循环结构A
 * 
 * 3.
 * 内层循环结构遍历一边，只相当于外层循环循环体执行了一次
 * 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m*n次
 * 
 * 内层控制行数，外层控制列数
 * 
 * 
 */
public class ForForTest {
	
	public static void main(String[] args) {
		
		//******
		for(int i = 1;i <= 6;i++){
			
			System.out.print('*');
		}
		
		/*
		  ******
		  ******
		  ******
		  ******
		*/
		for(int j = 1;j <= 4;j++){
			
			for(int i = 1;i <= 6;i++){
			
				System.out.print('*');
			}
			System.out.println();
		}
		/*			i(行号)     j(*的个数)	
		  *			1		   1
	      **		2		   2
		  ***       3		   3
		  ****		4		   4
		  *****		5 		   5
		*/
		for(int j = 1;j <= 5;j++){//控制行数
			
			for(int i = 1;i <= j;i++){//控制列数（个数）
			
				System.out.print('*');
			}
			System.out.println();
		}				
	}
}
		  /*		i(行号)     j(*的个数)	
		  *****		1		   5
	      ****		2		   4
		  ***       3		   3
		  **		4		   2
		  *			5 		   1
		  */
		for(int j = 1;j <= 5;j++){//控制行数
			
			for(int i = 1;i <= 6-j;i++){//控制列数（个数）
			
				System.out.print('*');
			}
			System.out.println();
		}

/*练习1：九九乘法表
*/
public class ForForTest {
	public static void main(String[] args) {
			
       		 for(int i = 1;i < 10;i++){
					
				for(int j = 1;j <= i;j++){
					
					sum = j * i;
					System.out.print(j+ "*" + i + "=" + i * j + " ");
					
				}
				System.out.println();
			}	
	}
}

/*练习2：100以内的所有质数
* 质数：只能被1和它本身整除的自然数
* 从2开始，到这个数-1结束为止，都不能被这个数整除
*/
public class ForForTest{
	public static void main(String[] args) {
			long start = System.currentTimeMillis();
			boolean isFlag = true;
			
			for(int i = 2;i <= 100000;i++){
				//for(int j = 2;j < i;j++)
				for(int j = 2;j <= Math.sqrt(i);j++){//从2开始，到这个数-1结束为止，都不能被这个数整除
					
					if(i % j ==  0){//从2开始，到这个数-1结束为止，有一个能除尽就返回false
						isFlag = false;
						break;//提高执行效率
					}
	
				}
				if(isFlag){
					System.out.println(i);
				}
				isFlag = true;//从第一个非质数4返回false之后if(isFlag)就没机会执行了，因此在此之后要重置isFlag的值。
				
			}
			long end = System.currentTimeMillis();
			System.out.println(end - start);
	}
}

break和continue关键字的使用

/*break和continue关键字的使用
 * 			使用范围			循环中使用作用(不同点)		相同点
 * break：  switch-case     
 * 			循环结构中			结束当前循环				关键字后面不能声明语句
 * 
 * continue 循环结构中			结束当此循环				关键字后面不能声明语句
 * 
 */
import java.util.Scanner;
public class ForForTest{
	public static void main(String[] args) {
			
			for(int i = 2;i < 10;i++){
						
					if(i % 4 ==  0){
						//break;//1 2 3
						continue;//1 2 3 5 6 7 9 10
					}
					System.out.println(i);
			}
        
			label:for(int i = 1;i <= 4;i++){
	
					for(int j = 1;j <= 10;j++){
					
						if(j % 4 == 0){
							//break;//默认跳出包裹此关键字最近的一层循环。
							//continue;
							//break label;//指定结束标识的一层循环结构
							continue label;//指定结束标识的一层循环结构的当此循环
						}
						System.out.print(j);
					}
					System.out.println();
			}
	}
}

项目一

public class P1Test {
	public static void main(String[] args) {
		int balance = 1000;
		String details = "收支\t账户金额\t收支金额\t说    明\n";
		
		boolean isFlag = true;
		while(isFlag){	
		System.out.println("-----------------家庭收支记账软件-----------------\n");
		System.out.println("                    1 收支明细");
		System.out.println("                    2 登记收入");
		System.out.println("                    3 登记支出");
		System.out.println("                    4 退    出\n");
		System.out.println("                    请选择(1-4)：");
		
		char num = Utility.readMenuSelection();
		
		switch(num){
		
		
		case'1':
			System.out.println("-----------------当前收支明细记录-----------------");
			System.out.println(details);		
			System.out.println("--------------------------------------------------");
			break;
		case'2':
			System.out.println("本次收入金额：");
			int income = Utility.readNumber();
			System.out.println("本次收入说明：");
			String explain = Utility.readString();
			
			balance += income;
			
			details += "收入" + "\t" + balance + "\t" + income + "\t" + explain + "\n";
			System.out.println("---------------------登记完成---------------------\n");
			break;
		case'3':
			System.out.println("本次支出金额：");
			int expend = Utility.readNumber();
			System.out.println("本次支出说明：");
			String explain1 = Utility.readString();
			
			balance -= expend;
			
			details += "支出"+ "\t"  + balance + "\t" + expend + "\t" + explain1 + "\n";
			System.out.println("---------------------登记完成---------------------\n");
			break;
		case'4':
			System.out.print("确认是否退出(Y/N)：");
			char exit = Utility.readConfirmSelection();
			if(exit == 'Y'){	
				isFlag = false;				
			}		
		}
		}
	}

}