MyDiary_2020.9.27

For循环的举例

/*


	1)求1-100之间的和
	2)1-100之间的偶数和
	3)求5的阶乘!
	
		阶乘:
		5!= 5 * 4 * 3 * 2 * 1 
		
		n! = n * (n-1)!
	
	求和实现/求阶乘实现:
	
	1)定义最终结果变量
	2)按照需求:使用循环将数据一一获取出来
	3)判断...
*/

class ForTest{
	public static void main(String[] args){
		//1-100之间的和
		//定义一个最终结果变量:
		int sum = 0 ;
		
		//循环实现:告诉范围:明确循环次数
		for(int x = 1; x <= 100 ; x ++){
		//x=1,2,3....100
			//sum += x ;
			sum = sum + x ;
		}
		System.out.println("1-100之间的和是:"+sum) ;
		
		System.out.println("-------------------------") ;
		
		//1-100之间的偶数和
		
		//定义一个最终结果变量:
		int sum2 = 0 ;
		for(int x = 1 ; x <= 100 ; x ++){
		//x=1,2,3,4....100  //将数据获取出来了
			if(x %2 == 0 ){//判断,帅选出来!
				sum2 += x ;
			}
		}
		System.out.println("1-100之间的偶数和是:"+sum2) ;
		
		System.out.println("-------------------------") ;
		
		//方式2：
		int sum3 = 0 ;
		for(int x = 0 ; x <= 100 ; x +=2){
				sum3 += x ;
		}
		System.out.println("1-100之间的偶数和是:"+sum3) ;
		
		System.out.println("-------------------------") ;
		
		//求5的阶乘!
	
		//阶乘:
		//5!= 5 * 4 * 3 * 2 * 1 
		//定义一个最终结果变量
		int jc = 1 ;
		for(int x = 2 ; x <= 5 ; x ++){
		//x =1 
			//获取出来:1,2,3,4,5
			jc *= x ; 
			//1) jc = jc * 1  = 1 * 1 = 1 
			//2)jc = 1* 2 
			//..
		}
		System.out.println("5的阶乘是:"+jc) ;
	}
}

/*
	需求:在控制台输出所有的水仙花数 
	
	
什么是水仙花数:
		1)三位数----->已经给告诉范围了
		2)满足条件:
		 这三位数:没一个位上的数据本身的立方 相加的结果就是该数据本身
		 举例
			153 = 1*1*1 + 5 * 5 *5 + 3 * 3 * 3
			
分析:
		1)三位数----->已经给告诉范围了  使用for循环
		2)需要每个位上的数据
		
				如何获取每个位上的数据呢?
				举例:153
							获取个位
							
								定义变量
								int  ge = 153 % 10(对10求余)  3
							
							获取十位:
								int shi = 153 /10(取整) % 10(取整的结果对10求余)  5
								
							获取百位:
								int bai = 153 /10 /10  % 10 (取整结果对10求余) 1
		3)在循环中满足的条件:
			
			bai*bai*bai + shi * shi *shi + ge * ge * ge 
			结果和数据(100-999之间的数据)本身相等,就输出这个变量即可!
													

		
		
*/
class ForTest2{
	public static void main(String[] args){
		
		//1)三位数----->已经给告诉范围了  使用for循环
		for(int x = 100; x < 1000; x ++){
			//需要每个位上的数据
			//获取个位,十位,百位的数据
			//定义变量
			int ge = x % 10 ;
			int shi = x / 10 % 10 ;
			int bai = x /10 /10 % 10;
			
			
			//在循环中满足的条件:
			/*
				bai*bai*bai + shi * shi *shi + ge * ge * ge 
			结果和数据(100-999之间的数据)本身相等,就输出这个变量即可!
			*/
			if(x == (ge * ge * ge+shi * shi *shi+bai*bai*bai)){
				//输出x即可
				System.out.println("水仙花数据是:"+x) ;
				/*
					水仙花数据是:153
					水仙花数据是:370
					水仙花数据是:371
					水仙花数据是:407
				*/
			}
		}
	}
}

/*
	
需求:
	统计所有的水仙花数有多少个?
	
	
分析:
	1)定义一个统计变量:int count = 0
	2)水仙花数:三位数----for循环
	
	3)获取每一个数据的数据
				获取个位
							
				定义变量
					int  ge = 153 % 10(对10求余)  3
				
				获取十位:
					int shi = 153 /10(取整) % 10(取整的结果对10求余)  5
					
				获取百位:
					int bai = 153 /10 /10  % 10 (取整结果对10求余) 1
					
	4)在循环中满足的条件:
			
			bai*bai*bai + shi * shi *shi + ge * ge * ge 
			结果和数据(100-999之间的数据)本身相等,统计变量++即可!

	
*/

class ForTest3{
	public static void main(String[] args){
		
		//1)定义统计变量
		int count = 0 ;
		
		//2)水仙花数:三位数:明确范围
		for(int x = 100 ; x <= 999 ; x ++){
			//定义三个变量:获取每个位的数据本身
			int ge = x % 10 ;
			int shi = x / 10 % 10 ;
			int bai = x /10 /10 % 10 ;
			
			//满足的条件
			if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
				//统计变量++
				count ++ ; //1 //2
				
				System.out.println("x:"+x) ;
			}
		}
		
		System.out.println("水仙花共有"+count+"个") ;
	}
}

while循环举例

/*
	while循环语句格式:
基本格式
	while(初始化语句以及条件表达式){
		 循环体语句;
		 步长语句(控制体语句) ;
	}
	
扩展格式:(推荐)
		初始化语句;
		while(条件表达式){
			循环体语句;
			步长语句(控制体语句) ;
		}
		
执行流程:
		1)首先初始化语句进行赋值
		2)判断条件表达式是否成立,如果成立,执行循环体语句
		   再次执行步长语句;
		3)继续判断条件表达式是否成立,如果成立,执行循环体语句
		  再次执行步长语句;
		  ...
		  ...
		  
		4)当条件表达式为false,不成立,while循环语句结束
		
需求:	
	控制台输出5次"helloworld"


*/
class WhileDemo{
	public static void main(String[] args){
		
		//for循环
		for(int x = 0 ; x < 5 ; x ++){//x = 0,1,2,3,4
			System.out.println("helloworld") ;
		} 
		System.out.println("--------------------------") ;
		
		//while循环:扩展 格式
		/*
			
		初始化语句;
		while(条件表达式){
			循环体语句;
			步长语句(控制体语句) ;
		}
		*/
		int j = 1 ;
		while(j <= 5){
			System.out.println("helloworld") ;
			j ++ ;
		}
	}
}

/*
	while循环和for循环的区别?
	
	1)从格式上不太一样 
		for(初始化语句;条件表达式;步长语句){
			循环体;
		}
		
		初始化语句;
		while(条件表达式){
			循环体语句;
			步长语句;
		}
	2)从内存角度:(是否节省内存空间)

				变量:		编译时期变量   运行时期变量
						   int i  = 10 ;      Integer(引用类型) i = 100 ;
						   
		for循环:for循环语句结束,变量从内存中释放掉了,节省内存空间(优先)
		while循环:while循环语句结束,依然可以访问变量,耗费内存空间
		
	
	
	变量/对象   最终程序结束,都需要垃圾回收器GC
				(jvm:假想计算机--->开启:垃圾回收线程)
				
				
	3)应用场景:是否明确次数
		针对for循环:(使用居多) 明确循环次数
			举例:			==   :基本类型: int a = 10 ; int b = 20 ;
					模拟用户登录, 给三次机会! (String类:equals())
					
		针对while循环:(使用:仅此for) :不明确循环次数
			举例:
					猜数字游戏: (不知道猜多少次,能猜中!)
							键盘录入一个数据 
							
*/

class WhileDemo2{
	public static void main(String[] args){
		
		//需求:分别使用for,while循环控制台输出3次 "我爱高圆圆"
		
		for(int x = 1; x <=3 ; x ++){
			System.out.println("我爱高圆圆") ;
		}
		//System.out.println(x) ;
		
		System.out.println("---------------") ;
		//初始化语句:
		int j = 1 ;
		while(j <=3 ){
			System.out.println("我爱高圆圆") ;
			j ++ ;
		}
		System.out.println(j) ;
		
		System.out.println("over") ;
		
	}
}

/*
	两个死循环
		
		格式1:
			for(;;){
				
				循环体语句;
			}
			
		格式2 :(推荐)
			while(true){
				
				循环体语句;
			}
*/

class WhileDemo3{
	public static void main(String[] args){
		
		//格式1;
		/*
		for(;;){
			System.out.println("我很开心,学习了死循环....") ;
		}
		*/
		
		//格式2:
		while(true){ //恒成立
			System.out.println("我很开心,学习了死循环....") ;
		}
		
		//死循环:要灵活使用: 
		//学习:java.lang.Math:数学运算(提供三角函数/基本的数学运算)
		//方法random()--->产生随机数
	}
}

/*
	java.lang.Math
	Math 
	类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
	
	获取随机数的方法
		使用:
			public static double random() :取值范围[0.0,1.0)
			static:静态的 (面向对象讲)
			
			
	需求:使用Math类中的方法 random()获取一个1-100之间的随机数
	
	然后在键盘录入一个int类型的数据,猜产生的随机数!
	
	分析:
			
			1)使用Math的random()产生一个1-100之间的随机数
			2)然后使用Scanner:键盘录入录入int类型的数据
			
			while(true){ //保证不断录入数据,不知道录入多少次,使用while循环
			3)判断当前录入的数据和随机数的数据进行对比
			
				要么大了,提示"数据大了"
				小了,提示"数据小了"
				相等,
						break ; 结束while循环
				
			}
			
			
*/
//导包
import java.util.Scanner;
class WhileTest2{
	public static void main(String[] args){
		
		//测试
		//获取一个随机数:使用jdk提供的一个类Math
		//double number = Math.random() ;
		//System.out.println("number:"+number) ;
		
		//获取1-100之间的随机数 (整数:默认int类型)
		//int number = (int)(Math.random()*100 + 1);
		//System.out.println(number) ;
		
		//产生一个随机数:1-100之间
		int number = (int)(Math.random()*100+1) ; //99
		
		//为了保证不断的录入数据,使用while(true)
		
		//定义一个统计变量
		//int count = 0 ;
		while(true){
		
		//	count ++ ;//统计变量++
			//键盘录入数据
			Scanner sc = new Scanner(System.in) ;
			
			
			//提示并接收数据
			System.out.println("请您输入一个要猜的数据:") ;
			int guessNumber = sc.nextInt() ;
			
			//判断
			//键盘录入的数据大于产生的随机数
			if(guessNumber > number){
				System.out.println("您要猜的数据大了...") ;
			}else if(guessNumber < number){
				System.out.println("您要猜的数据小了...") ;
			}else{
				System.out.println("恭喜您,猜中了!!!") ;
				break ;//结束了
			}
		}
		
	}
}

do while()循环举例

/*
	do-while循环语句的格式: (开发中:使用不多,在java原码中)
	
	格式:
		初始化语句;
		do{
			循环体语句;
			步长语句(控制体语句) ;
		}while(条件表达式) ;
		
执行流程:
	1)初始化语句赋值
	2)直接执行循环体语句---->步长语句--->条件表达式
	....
	....
	
	特点:循环体至少执行一次 (它和while,for的区别)
		

		需求:控制台使用do-while循环输出5次"helloworld"
	
*/
class DoWhileDemo{
	public static void main(String[] args){
		
		/*
			初始化语句;
		do{
			循环体语句;
			步长语句(控制体语句) ;
		}while(条件表达式) ;
		*/
		int x = 6 ;
		do{
			System.out.println("helloworld");
			x ++ ;
		}while(x <= 5) ;
	}
}

For循环嵌套举例

/*
	for循环的嵌套:
	
	for(初始化语句;条件表达式;步长语句){
		
		
		//循环体语句
		for(初始化语句;条件表达式;步长语句){
		
			
		}
	}
	
需求:
控制台输出:四行五列的*形
*****
*****
*****
*****
	
*/

class ForForDemo{
	public static void main(String[] args){
		
		//原始的做法:
		System.out.println("*****") ;  //System.out.println():打印内容并换行
		System.out.println("*****") ;
		System.out.println("*****") ;
		System.out.println("*****") ;
		System.out.println("------------------------------") ;
		
		//改进: 上面的代码:重复度高
		//*****
		//一次输出一个*,而且要保证5个*在同一行上 
		//System.out.print("*"): 打印内容不换行
		
		
		//第一行:
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		//换下一行:
		System.out.println() ; //空行
		
		//第二行:
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.println() ;
		
		//第三行:
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.println() ;
		
		//第四行:
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.print("*") ; 
		System.out.println() ;
		
		System.out.println("------------------------------") ;
		
		//上面每一行:输出* 代码重复度高,继续优化改进
		//见到重复性的代码:循环改进
		//每一行的*,使用循环
		//第一行
		for(int x = 0 ; x < 5 ;x++){ //0,1,2,3,4
			System.out.print("*") ; 
		}
		System.out.println() ; //空行
		
		
		//第二行
		for(int x = 0 ; x < 5 ;x++){ //0,1,2,3,4
			System.out.print("*") ; 
		}
		System.out.println() ; //空行
		
		//第三行
		for(int x = 0 ; x < 5 ;x++){ //0,1,2,3,4
			System.out.print("*") ; 
		}
		System.out.println() ; //空行
		
		//第四行
		for(int x = 0 ; x < 5 ;x++){ //0,1,2,3,4
			System.out.print("*") ; 
		}
		System.out.println() ; //空行
		
		System.out.println("--------------------------") ;
		
		//上面代码:重复度还是很高,每一行都一个for循环+输出空行(换行)
		
		for(int x = 0 ; x < 4 ; x ++){//x = 0,1,2,3 (循环四次)    :外层循环控制行数
			
			for(int y = 0 ; y < 5 ;y++){ //0,1,2,3,4 //内存循环控制:列数
				
				System.out.print("*") ; 
			}
			System.out.println() ; //空行
		}
		
		System.out.println("----------------------------------") ;
		
		//6行7列
		for(int x = 0 ; x < 6 ; x ++){
			for(int y = 0 ; y < 7 ; y ++){
				System.out.print("*") ;
			}
			System.out.println();
		}
	}
}

/*
	打印*形
列数随着行数在变化

*
**
***
****
*****


分析:
	//列数在变化
	x:表示行数:0,1,2,3,4
	y:表示列数
	
	
	第一行: 1列 
	 int y = 0 ,y<=0  y=0, 1个*
	第二行:2列
	int y = 1 , y<=1 ,  y=  0,1    2 个*
	第三行:3列
	int y = 2, y <=2,    y=0,1,2   3 个 *
	
	第四行:4列
	int y = 3 , y <= 3  , y=0,1,2,3  4个*
	
	第五行:5列
	int y = 4,y <=4   , y =0,1,2,3,4   5个*
	
				y<= x 就可以
	


*/

class ForForDemo2{
	public static void main(String[] args){
		//打印:5行5列
		for(int x = 0 ; x < 5 ; x ++){ //行数
			for(int y = 0 ; y < 5 ; y ++){//列数
				System.out.print("*") ;
			}
			System.out.println() ;
		}
		
		System.out.println("-----------------------------") ;
		
		//列数在变化
		for(int x = 0 ; x < 5 ; x ++){//行数:0,1,2,3,4
			for(int y = 0 ; y <= x ;y ++){//列数
					//x=0 , y<=0  		 *
					//x= 1, y<=1  0,1	 **
					//x = 2  y<=2  0,1,2 ***
					//x =3, y<=3   0,1,2,3 ****
					//x = 4 y<=4  0,1,2,3,4 *****
					System.out.print("*") ;
			}
			System.out.println() ;
		}
		
		
	}
}

/*
	需求:99乘法表
	
	
打印以下*形
*
**
***
****
*****
******
*******
********
*********

1*1 = 1 
1*2 = 2	 2*2 = 4
1*3 = 3  2*3 = 6   3*3 = 9 
1*4 = 4                          ........
	
	                                                 ....
													 
													 
	转移字符:
		\t : 制表符号  ----->类似于文本文件中那个tab键 :缩进
		\n : 换行符号
		
		后面学习:IO流(输入/输出) :
		windows操作系统:换行符号"\r\n"
													 
*/

class ForForTest{
	public static void main(String[] args){
		
		//输出上面*形
		for(int x = 0 ;  x <9 ; x ++ ){//控制行数:外层循环
			for(int y = 0 ; y <=x ; y++){//控制列数:内层循环
				System.out.print("*") ;
			}
			System.out.println() ;
		}
		
		System.out.println("-------------------------------------") ;
		
		//99乘法表:
		//为了有数据,从1开始
		for(int x = 1 ; x <= 9 ; x ++){//外层循环控制行数
			for(int y = 1 ; y<=x ; y ++){//内层循环
				//输出
				System.out.print( y+"*" + x +"="+(y*x)+"\t") ;
			}
			System.out.println() ;
			
		}
	}
}

跳转控制语句举例

/*
	跳转控制语句:
	break  :中断,结束
	continue: 结束当前循环,立即进入下一次循环
	return :结束方法方法去使用的!(结合方法)
	
	break:中断,结束的意思
	
	不能单独使用,没有意义!
	
	在switch中以及循环中使用!
	
	循环中使用:
			1)可以在单层循环中使用
			2)早期的使用:用在for循环嵌套中使用(外层循环,内层循环)
			
				标签语句
						给外层循环/内层循环中起一个名字
						
					格式:标签名称:for(初始化语句;条件表达式;步长语句){...}
									标签名称:for(){}
									
	循环嵌套:应用场景:
	
		后期使用:
				增强for循环: 遍历集合
				
			类上于:	HashMap<String,ArrayList<>> 集合嵌套集合

*/
class BreakDemo{
	public static void main(String[] args){
		
		//break ;//在 switch 或 loop 外部中断
		
		for(int x = 0 ; x <10 ; x ++){
		
			//0,1,2,3,4,5,6,7,8,9
			//判断
			if(x == 2){
				break ; //单层循环中使用
			}
			System.out.println(x) ;//0,1
		}
		System.out.println("over") ;
		System.out.println("--------------------------------");
		
		
		//标签语句:
		//标签名称: for()...
		wc:for(int x = 0; x < 4 ; x ++){//外层循环
			nc:for(int y = 0 ; y < 5 ; y ++){//内层循环
					//if(x == 2){ //第三行的时候结束 :结束外层循环
						//break wc  ;
						//break nc ;
					//}

					if(y == 2){
						break nc ;
					}
					System.out.print("*") ;
				
			}
			System.out.println();
		}
		
	}
}

/*
	continue: 结束当前循环,立即进入下一次循环
	
	单独不能使用
	
	结合循环语句中使用
	
	
	需求: 笔试题
		for(int x = 1 ; x <=10 ; x ++){
			//1,2,3,4,5,6,7,8,9,10
			//x = 1 ,x = 2, x = 3
			if(x % 3 == 0){ //x = 3 ,x = 6 , x = 9
				//此处补全代码
				break ;
				
				continue ;
				
				System.out.println("我爱Java...") ;
			}
			
			System.out.println("我爱Java...") ; //1次  //2次
				
			
		}
		
		//1)在控制台2次  "我爱Java..."
				break ;
		//2)在控制台输出7次 "我爱Java..."
				continue
		//3)在控制台输出13次 "我爱Java..."
			System.out.println("我爱Java...") ;

*/

class ContinueDemo{
	public static void main(String[] args){
		
		//continue ;  //continue 在 loop 外部
		
		for(int x = 0 ; x < 10 ; x ++){
			//0 ,1,2,3
			//判断
			if(x == 3){
				continue ; //结束当前循环,立即下次循环
			}
			System.out.println(x) ; //0,1,2,4
		}
		
		System.out.println("over") ;
	}
}

/*
	return:就是结束方法使用的!
	
	return是具体用在具有返回值类型的方法中使用!(结合方法)
	
	什么是方法----->方法的概念以及注意事项!
	
	
	
*/
class ReturnDemo{
	public static void main(String[] args){
		System.out.println("程序开始了...")  ;
		for(int x = 0 ; x < 10 ; x ++){
			
			
			if(x == 2){
				//break ;//中断,结束,循环语句中语句break,结束了
				//continue ;立即结束当前循环,进入下一次循环:x=2 :不会出现
				return ;//当前方法结束了
			}
			System.out.println(x) ;
			
		}
		System.out.println("程序结束了...") ;
		
		System.out.println("over...") ;
	}
}

方法的举例

/*
	什么是方法:
		
		将一个独立的代码块{}抽取出来并为当前这个起名字!(作用:提高代码的复用性)
		
	方法的概念:
		使用{}将代码包裹起来,并给这个代码起一个名字:方法名
		---->以后直接使用方法名调用.  {}代码块
		
		
	如何定义方法?
	
	
	
	两种:
		有返回值类型的方法的定义
		没有返回值类型的方法定义
		
		
		第一种:有返回值类型的方法的定义
		固定格式:
		public static 返回值类型 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名称2...){
				
				业务需求...
				return 结果;
		}
		
		格式的详细介绍:
		 权限修饰符:public(公共的,访问权限足够大) static(静态)
		 返回值类型:数据类型(目前基本数据类型:四类八种: )
				举例:求两个数据之后  结果:int类型
		方法名:遵循标识符的规则(见名知意)
				单个单词:全部小写
				多个单独:第一个单词小写,从第二个单词开始,每个单词首字母大写,其余小写
				    小驼峰命名法!
		形式参数类型:数据类型(目前基本数据类型:四类八种: )
		参数名称:变量名称
		
		return: 这个方法调用完毕了,带回具体的结果!
		
		
		有返回值类型的方法调用:
		1)单独调用(没有意义)
		2)输出调用:不推荐
		3)赋值调用:推荐
		
		
			
		
需求:
	求和两个数据的和,使用方法完成这个需求! (没有说明具体数据类型:默认int)
	
*/
class FunctionDemo{
	public static void main(String[] args){
	
		//两个变量
		//a,b:两个实际参数
		int a = 10 ;
		int b = 20 ;
		
		
		//调用方法 :方法中需要传递实际参数
		//add(a,b); //单独调用
		
		//输出调用(可以用,不推荐!)
		//直接输出,获取到的结果无法继续进行下一步操作!
		//System.out.println(add(a,b)) ;
		
		//3)赋值调用:推荐:获取到结果,可以继续其他业务操作!
		
		
		int  result = add(a,b) ;
		System.out.println("result:"+result) ;
		
	}
	/*
	求和两个数据的和
		定义方法:
		
		两个明确:
			
			1)明确返回值类型: int类型
			2)明确参数类型以及参数个个数
					int类型
					2个参数求和
	
		public static 返回值类型 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名称2...){
		
				业务需求...
				return 结果;
		}
	*/
	public static int add(int m,int n){//m =a =10, n = b = 20 将实际参数值传递进来!
		//我们自己的业务
		int c =  m + n ;
		
		//返回结果数据
		return c ;
		
	}
}