java 将年月日转为年月 java中年月日

ChapterTwo---Java基本语法：变量、运算符与流程控制（下）

• 程序流程控制

• ① 顺序结构
• ② 分支结构

• ⑴if-else结构
• ⑵ switch-case结构

• ③ 循环结构

• ⑴ 循环结构之for循环

• ●代码演示

• ⑵ 循环结构之while循环

• ●代码演示

• ⑶ 循环结构之do-while循环

• ●代码演示
• ●循环语句综合例题

• ⑷嵌套循环

• ●代码演示
• ●九九乘法表
• ●素数问题一

• ④ 特殊关键字的使用break、continue

• ⑴ break的使用

• ●代码演示

• ⑵continue的使用

• ●代码演示
• ●break-continue综合演示
• ●素数问题优化一
• ●素数问题优化二

• ⑤return的使用
• ⑥特殊流程控制语句说明

程序流程控制

① 顺序结构

② 分支结构

⑴if-else结构

if-else的使用说明

1. 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量。
2. 语句块只有一条执行语句时，一对{}可以省略，但建议保留
3. if-else语句结构，根据需要可以嵌套使用。
4. 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略。
5. 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓。当多个条件是“包含”关系时，“小上大下 / 子上父下”

Scanner类的使用说明

import java.util.Scanner;
/*
 * 如何从键盘获取不同类型的变量：需要使用Scanner类
 * 
 * 具体实现步骤：
 * 1.导包：import java.util.Scanner;
 * 2.Scanner的实例化：Scanner scan=new Scanner(System.in)
 * 3.调用Scanner类的相关方法，来获取指定类型的变量:字符串是next()；基本类型就是nextXxx()，但是没有nextChar()一说
 * 
 * 注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不
 * 匹配时，会报异常：导致程序终止。
 */
public class ScannerTest {

	public static void main(String[] args) {
		//Scanner的实例化	
		Scanner scan=new Scanner(System.in);
		//调用Scanner类的相关方法
		System.out.println("请输入你的姓名：");
		String name=scan.next();
		
		System.out.println("请输入你的芳龄:");
		int age=scan.nextInt();
		System.out.println(age);
		
		System.out.println("请输入你的体重：");
		double weight=scan.nextDouble();
		System.out.println(weight);
		
		System.out.println("请输入你的性别");
		String sex=scan.next();
		char sexChar=sex.charAt(0);
		System.out.println(sexChar);
		
		System.out.println("是否相中我了：true/false");
		boolean bool=scan.nextBoolean();
		System.out.println(bool);
		
		//课后练习4：如何获取一个随机数：10-99
		//方式一：
		int value=(int)(Math.random()*90+10);//[0.0,1.0)-->[0.0,90.0)--->[10.0,100.0)--->[10,100)
		//方式二：
		int value1=(int)(Math.random()*90)+10;//[0.0,1.0)--->[0.0,90.0)--->[0,90)--->[10,100)
		//总结[a,b)的随机
		//int value=(int)(Math.random()*(b-a+1)+a);
		System.out.println(value);
		System.out.println(value1);
	}
}

import java.util.Scanner;

/*
 * 分支结构中的if-else(条件判断结构)
 * 
 * 一、三种结构
 * 第一种：
 * if(条件表达式){
 * 
 * }
 * 
 * 第二种：二选一
 * if（条件表达式）{
 * 		执行表达式1
 * }else{
 * 		执行表达式2
 * }
 * 
 * 第三种：多选一
 * i条件表达式f（条件表达式）{
 * 		执行表达式1
 * }else if（）{
 * 		执行表达式2
 * }
 * else if（）{
 * 		执行表达式3
 * }
 * ...
 * else{
 * 		执行表达式n
 * }
 * 
 * 说明：
 * 1.else结构是可选的。
 * 2.针对条件表达式：
 * 		>如果多个条件表达式之间时“互斥”关系（或没有交集的关系），哪个判断和执行语句声明在上面还是下面，无所谓。
 * 		>如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结果声明在上面。
 * 		>如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
 */
public class ifTest {

	public static void main(String[] args) {
		//举例1
		int heartBeats=70;
		if(heartBeats < 60 || heartBeats>100){
			System.out.println("需要做进一步检查");
		}
		System.out.println("检查结束");
		
		//举例2
		int age=23;
		if(age<18){
			System.out.println("你还可以看动画片");
		}else{
			System.out.println("可以看成人电影了");
		}
		
		//举例3
		if(age<0){
			System.out.println("您输入的数据非法");
		}else if(age<18){
			System.out.println("青少年时期");
		}else if(age<35){
			System.out.println("青壮年时期");
		}else if(age<60){
			System.out.println("中年时期");
		}else if(age<120){
			System.out.println("老年时期");
		}else{
			System.out.println("你是要成仙啊");
		}
		
		/*练习题:岳小鹏参加Java考试，他和父亲岳不群达成承诺：
		如果：
		成绩为100分时，奖励一辆BMW；
		成绩为(80，99]时，奖励一台iphone xs max；
		当成绩为[60,80]时，奖励一个 iPad；
		其它时，什么奖励也没有。
		请从键盘输入岳小鹏的期末成绩，并加以判断*/
		
		System.out.println("请输入岳小鹏的期末成绩：（0-100）");
		Scanner scan=new Scanner(System.in);
		
		int score=scan.nextInt();
		if(score==100){
			System.out.println("奖励一辆BMW");
		}else if(score>80&&score<=99){
			System.out.println("奖励一条iPhone xs max");
		}else if(score>=60 && score<=80){
			System.out.println("奖励一个ipad");
		}else{
			System.out.println("什么奖励也没有");
		}
	}
}

⑵ switch-case结构

switch语句有关规则

1. switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
2. case子句中的值必须是常量，不能是变量名或不确定的表达式值；
3. 同一个switch语句，所有case子句中的常量值互不相同；
4. break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾;
5. default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default。

package com.shangguigu.flowcontrol;

import java.util.Scanner;

/**
 * 
 * @author 刘瘦瘦
 *分支结构之二：switch-case
 *
 * 1.格式
 * switch(表达式){
 * 	case 常量1：
 * 		//执行语句1;
 * 		//break;
 *  case 常量2：
 * 		//执行语句1;
 * 		//break;
 *	...
 *	default:
 *		执行语句n;
 *		//break;
 * }
 * 2.说明：
 * ①根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
 * 当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case末尾结束为止。
 *
 * ②break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
 * 
 * ③switch结构中的表达式，只能是如下的6中数据类型之一：byte、short、char、int、枚举类型（JDK5.0）新增
 * String类型（JDK7.0新增）
 * 
 * ④case之后只能声明常量。不能声明范围。
 * 
 * ⑤break关键字是可选的。
 * 
 * ⑥default：相当于if-else结构中的else
 * default结构是可选的，而且位置是灵活的。
 * 
 * ⑦           1. 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
		2. 我们写分支结构时，当发现既可以使用switch-case,（同时，switch中表达式的取值情况不太多），
		  又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。
 */
public class SwitchCaseTest {

	public static void main(String[] args) {
		int number=2;
		switch(number){
			case 0:
				System.out.println("zero");
				break;
			case 1:
				System.out.println("one");
				break;
			case 2:
				System.out.println("two");
				break;
			default:
				System.out.println("three");
				//break;可加可不加，最后加上
		}
		
		String season="autumn";
		switch(season){
			case "spring":
				System.out.println("春暖花开");
				break;
			case "summer":
				System.out.println("夏日炎炎");
				break;
			case "autumn":
				System.out.println("秋高气爽");
				break;
			case "winter":
				System.out.println("冬雪皑皑");
				break;
			default:
				System.out.println("季节输入有误");
				break;
		}
		
		//*****如下的两种情况都编译不通过****
		//情况一
		boolean isHandsome = true;
		/*switch(isHandsome){
		
		case true:
			System.out.println("我好帅啊~~~");
			break;
		case false:
			System.out.println("我好丑啊~~~");
			break;
		default:
			System.out.println("输入有误~~~");
		}*/
		
		//情况二：
		/*
		int age = 10;
		switch(age){
		case age > 18:
			System.out.println("成年了");
			break;
		default:
			System.out.println("未成年");
		}
		*/
		
		/*
		例题：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

		说明：如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
		*/
		/*
		int score = 78;
		switch(score){
		case 0:

		case 1:

		case 2:

			...
		case 100:
		
		}
		*/

		/*
		int score = 78;
		if(score >= 60){
		
		}else{
		
		}
		*/
		
		int score = 78;
		switch(score / 10){
		case 0:
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			System.out.println("不及格");
			break;
		case 6:
		case 7:
		case 8:
		case 9:
		case 10:
			System.out.println("及格");
			break;

		}
		
		//更优的解决方案：
		switch(score / 60){
		case 0:
			System.out.println("不及格");
			break;
		case 1:
			System.out.println("及格");
			break;
		}
		//default是可选的
		
		/*
		编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天。

		2  15:  31 + 15

		5 7: 31 + 28 + 31 + 30 + 7 

		....

		说明:break在switch-case中是可选的
		*/
		Scanner scan=new Scanner(System.in);
		System.out.println("请输入2019年的month:");
		int month=scan.nextInt();
		System.out.println("请输入2019的day:");
		int day=scan.nextInt();
		
		//定义一个变量来保存天数
		int sumDays=0;
		//方式一：冗余
				/*
				
				if(month == 1){
					sumDays = day;
				}else if(month == 2){
					sumDays = 31 + day;
				}else if(month == 3){
					sumDays = 31 + 28 + day;
				}else if(month == 4){
					sumDays = 31 + 28 + 31 + day;
				}
				//...
				else{//month == 12
					//sumDays = ..... + day;
				}

				*/
		
		//方式二：冗余
				/*
				switch(month){
				case 1:
					sumDays = day;
					break;
				case 2:
					sumDays = 31 + day;
					break;
				case 3:
					sumDays = 31 + 28 + day;
					break;
				...
				}
				*/
		//方式三：
		switch(month){
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			sumDays += 28;
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}
		System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	
		/*
		从键盘分别输入年、月、日，判断这一天是当年的第几天
		 
		   注：判断一年是否是闰年的标准：
		       1）可以被4整除，但不可被100整除
			或
		       2）可以被400整除

		说明：
		1. 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
		2. 我们写分支结构时，当发现既可以使用switch-case,（同时，switch中表达式的取值情况不太多），
		  又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。

		*/
		System.out.println("请输入year：");
		int year=scan.nextInt();
		System.out.println("请输入month:");
		int month2=scan.nextInt();
		System.out.println("请输入day:");
		int day2=scan.nextInt();
		//定义一个变量来保存天数
		int sumDays2=0;	
		switch(month2){
		case 12:
			sumDays2 += 30;
		case 11:
			sumDays2 += 31;
		case 10:
			sumDays2 += 30;
		case 9:
			sumDays2 += 31;
		case 8:
			sumDays2 += 31;
		case 7:
			sumDays2 += 30;
		case 6:
			sumDays2 += 31;
		case 5:
			sumDays2 += 30;
		case 4:
			sumDays2 += 31;
		case 3:
			if((year%4==0&&year%100!=0)||year %400==0){
				sumDays2 += 29;
			}else{
				sumDays2 += 28;
			}
		case 2:
			sumDays2 += 31;
		case 1:
			sumDays2 += day2;
		}
		System.out.println(year+"年" + month2 + "月" + day2+ "日是当年的第" + sumDays2 + "天");	
	}
}

③ 循环结构

⑴ 循环结构之for循环

●代码演示

/**
 * For循环结构的使用
 * 一、循环结构的4个要素
 * ①初始化条件
 * ②循环条件--->是boolean类型
 * ③循环体
 * ④迭代条件
 * 
 * 二、for循环的结构
 * for(①;②;④){
 * 		③
 * }
 * 执行过程：①-②-③-④-②-③-④-...-②
 * 
 *
 */
public class ForTest {

	public static void main(String[] args) {
		
		for(int i=1;i<=5;i++){
			System.out.println("Hello World!");
		}
		//i:for循环内有效。出了for循环就失效了
		//Syste.out.println(i);
		
		//练习：
		int num=1;
		for(System.out.print('a');num<=3;System.out.print("c"),num++){
			System.out.print('b');
		}
		//输出结果：abcbcbc
		System.out.println();
		
		例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
		int sum=0;//记录所有偶数的和
		int count=0;//记录偶数的个数
		for(int i=1;i<=100;i++){
			if(i%2==0){
				System.out.println(i);
				sum+=i;
				count++;
			}
		}
		System.out.println("总和为:"+sum);
		System.out.println("个数为:"+count);
		
		/*题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
		比如：12和20的最大公约数是4，最小公倍数是60。*/
		
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入第一个整数：m");
		int m=sc.nextInt();
		System.out.println("请输入第二个整数：n");
		int n=sc.nextInt();
		
		//获取最大公约数（从大到小遍历）
		//1.获取两个数中的最小值
		int min=(m>=n)? m:n;
		//2.遍历
		for(int i=min;i>=1;i--){
			if(m%i==0 && n%i==0){
				System.out.println("最大公约数:"+i);//最大公约数:4
				break;
			}
		}
		
		//获取最小公倍数，取值范围是[两者中的最小数--两个数的乘积]
		//1.获取两个数中的最大值
		int max=(m>n)?m:n;
		//2.遍历
		for(int i=max;i<=m*n;i++){
			if(i%m==0 && i%n==0){
				System.out.println("最小公倍数为："+i);//最小公倍数为：60
				break;
			}
		}
	}
}

⑵ 循环结构之while循环

●代码演示

*
 * while循环的使用
 * 
 * 一、循环结构的四个要素
 * ①初始化条件
 * ②循环条件-->是boolean类型
 * ③循环体
 * ④迭代条件
 * 
 * 二、while循环的结构
 * 
 * ①
 * while（②）{
 * 		③；
 * 		④；
 * }
 * 执行过程：①-->②-->③-->④-->②-->③-->④-...-②
 * 说明：
 * 	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);//101
	}
}

⑶ 循环结构之do-while循环

●代码演示

/*
 * do-while循环的使用
 * 一循环的四个要素
 * 	①初始条件
 * 	②循环条件-->是boolean类型
 * 	③循环体
 * 	④迭代条件
 * 二、do-while循环结构
 * 	①
 * 	do {
 * 		③;
 * 		④;
 *  }while(②);
 *  
 *  执行过程：①-③-④-②-③-④-...-②
 *  说明：
 *  1.do-while循环至少会执行一次循环体！
 *  2.开发中，使用for和while更多一些。较少使用do-while
 */
public class DoWhileTest {

	public static void main(String[] args) {
		//遍历100以内的偶数，并计算所有偶数的和及偶数的个数
		int num=1;
		int sum=0;//记录总和
		int count=0;//记录个数
		do{
			if(num%2==0){
				System.out.println(num);
				sum+=num;
				count++;
			}
			num++;
		}while(num<=100);
		System.out.println("总和为:"+sum);
		System.out.println("个数为:"+count);
		
		
		//******体会do-while至少执行一次循环体*****
		int number1=10;
		while(number1>10){
			System.out.println("hello:while");//不输出
			number1--;
		}
		
		int number2=10;
		do{
			System.out.println("hello do-while");//输出
			number2--;
		}while(number2>10);		
	}
}

●循环语句综合例题

import java.util.Scanner;

/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

说明：
1.不在循环条件部分限制次数的结构：for（;;）或while（true）
2.结束循环有几种方式？
	方式一：循环条件部分返回false
	方式二：在循环体中，执行break
*/
public class ForWhile {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		
		int positiveNumber=0;//记录整数的个数
		int negativeNumber=0;//记录负数的个数
		
		for(;;){//while(true){
			int number=sc.nextInt();
			//判断number的正负情况
			if(number>0){
				positiveNumber++;
			}else if(number<0){
				negativeNumber++;
			}else{
				//一旦执行break，跳出循环
				break;
			}
		}
		System.out.println("输入的正数个数为："+positiveNumber);
		System.out.println("输入的负数个数为："+negativeNumber);
	}
}

⑷嵌套循环

●代码演示

/**
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环

2.
外层循环：循环结构B
内层循环：循环结构A

3. 说明
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次

4. 技巧：
   外层循环控制行数，内层循环控制列数
 *
 */
public class ForForTest {
	public static void main(String[] args) {
		//******
				//System.out.println("******");
				for(int i = 1;i <= 6;i++){
					System.out.print('*');
				}

				System.out.println("\n");

				/*
				******
				******
				******
				******
				*/
				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 i = 1;i <= 5;i++){//控制行数
					for(int j = 1;j <= i;j++){//控制列数
						System.out.print("*");
					
					}
					System.out.println();
				}
				
				/*			i(行号)		j(*的个数)   规律：i + j = 5 换句话说：j = 5 - i;
				****		1			4
				***			2			3
				**			3			2
				*			4			1
				*/	

				for(int i = 1;i <= 4;i++){
					for(int j = 1;j <= 5 - i;j++){
						System.out.print("*");	
					}
					System.out.println();
				}

				/*
				*
				**
				***
				****
				*****
				****
				***
				**
				*
				*/

				//略

		/*

		----* 
		---* * 
		--* * * 
		-* * * * 
		* * * * * 
		 * * * * 
		  * * * 
		   * * 
		    * 

		*/
			System.out.println("-----------------");
			//上半部分
			for(int i=1;i<=5;i++){
				for(int j=1;j<=5-i;j++){
					System.out.print(' ');
				}
				for(int z=1;z<=i;z++){
					System.out.print("* ");
				}
				System.out.println();
			}
			//下半部分
			for(int i=1;i<=4;i++){
				for(int j=1;j<=i;j++){
					System.out.print(" ");
				}
				for(int z=1;z<=5-i;z++){
					System.out.print("* ");
				}
				System.out.println();
			}
	}
}

●九九乘法表

/*
嵌套循环的应用1：

九九乘法表
1 * 1 = 1
2 * 1 = 2  2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81

*/
public class NineNineTable {
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以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

最小的质数是：2
*/
public class PrimeNumberTest {

	public static void main(String[] args) {
		
		boolean isFlag=true;//标识i是否被j除尽，一旦除尽，修改其值
		
		for(int i=2;i<=100;i++){
			
			for(int j=2;j<i;j++){
				if(i%j==0){//除尽
					isFlag=false;
				}
			}
			if(isFlag==true){
				System.out.println(i);
			}
			isFlag=true;
		}
	}
}

④ 特殊关键字的使用break、continue

⑴ break的使用

●代码演示

public class BreakTest {
	public static void main(String[] args) {
		for(int i=0;i<10;i++){
			if(i==3){
				break;
			}
			System.out.println("i="+i);//0,1,2
		}
	}
}

⑵continue的使用

●代码演示

public class ContinueTest {
	public static void main(String[] args) {
		for (int i = 0; i < 100; i++) {
			if (i%10==0) continue;
			System.out.println(i); 
		}
	}
}

●break-continue综合演示

/*
 * break和continue关键字的使用
 *			使用范围			循环使用的作用（不同点）			相同点
 * break：	switch-case、	结束当前循环					关键字后面不能声明执行语句
 * 			循环结构中	
 * 
 * continue：循环结构中			结束当次循环					关键字后面不能声明执行语句
 */
public class BreakContinueTest {
	public static void main(String[] args) {
		
		for(int i=1;i<=10;i++){
			if(i%4==0){
				break;//123
				//continue;//123567910
				//System.out.println("今晚迪丽热巴来约我喲");
			}
			System.out.print(i);
		}
		System.out.println();
		
		//*********************
		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);
			}
		}
	}
	}

●素数问题优化一

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

最小的质数是：2
*/
public class PrimeNumberTest2 {

public static void main(String[] args) {
		
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			
			//优化二：对本身是质数的自然数是有效的。
			//for(int j = 2;j < i;j++){
			for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
				
				if(i % j == 0){ //i被j除尽
					isFlag = false;
					break;//优化一：只对本身非质数的自然数是有效的。
				}
				
			}
			//
			if(isFlag == true){
				//System.out.println(i);
				count++;
			}
			//重置isFlag
			isFlag = true;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13

	}

}

●素数问题优化二

/*
100000以内的所有质数的输出。实现方式二
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest2 {
	public static void main(String[] args) {
		
		
		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			
			for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
				
				if(i % j == 0){ //i被j除尽
					continue label;
				}
				
			}
			//能执行到此步骤的，都是质数
			count++;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13

	}
}

⑤return的使用

⑥特殊流程控制语句说明