- JAVA语言语法
- 三、流程控制
- 1、程序流程控制概述
- 2、顺序结构
- 3、分支结构
- 4、分支结构语句练习
- 5、加深键盘类Scanner类的使用
- 6、分支结构语句练习2
- 7、分支结构&switch分支
- 8、循环结构& for 循环（重点）
- 9、循环结构&for循环练习
- 10、循环结构&while循环
- 11、循环结构&do-while循环
- 12、循环结构&关键字break
- 13、循环结构&关键字continue
- 14、循环结构&关键字return
- 15、循环结构&嵌套循环（多重循环）
- 16、循环结构&嵌套循环练习1
- 17、循环结构&嵌套循环练习2
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定给功能的小逻辑模块。
其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
（1）、顺序结构 : 程序从上到下逐行地执行，中间没有任何判断和跳转。 （2）、分支结构 : 根据条件，选择性地执行某段代码 有if、if-else、if-else if..else和switch-case的两种分支语句。 （3）、循环结构 根据循环条件，重复性地执行某段代码; 有while、do-while、for三种循环语句; 注意: JDK1.5开始提供了foreach的循环, 方便遍历集合、数组元素。2、顺序结构 3、分支结构
（1）、分支语句 if
（2）、分支语句 if-else
（3）、分支语句 if else if …else
if -else 使用说明：
(1)、条件表达式必须是布尔表达式(关系表达式或者逻辑表达式)、布尔变量;
(2)、语句块只有一条执行语句时，一队花括号{}可以省略，但是建议保留;
(3)、if-else语句结构，根据需要可以嵌套使用;
(4)、当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略;
(5)、当多个条件是“互斥”关系时，条件判断语句以及执行语句间顺序是无所谓的; 当多个条件是“包含”关系时，可遵循“小上大下/子上父下” （即是范围小的声明在范围大的上面）。
4、分支结构语句练习
代码演示：
package com.rucoding.d5;
public class IfelseDemo01 {
public static void main(String[] args) {
//举例1 if语句
int heartBeats = 179;
if(heartBeats < 60 || heartBeats > 100){
System.out.println("需要进一步做检查");
}
System.out.println("检查结束");
//举例2 if-else语句
int age = 23;
if(age < 18){
System.out.println("你还未成年呢");
}else{
System.out.println("你是成年人了");
}
//举例3 if else-if ...else 语句
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{ //根据实际的场景，这里的else是可以去除的。
System.out.println("你比乌龟还牛。。。");
}
}
}
5、加深键盘类Scanner类的使用
场景模拟：假如需要获取键盘的输入，此时需要从键盘获取不同类型的数据类型，需要使用到Scanner类。
具体步骤: 1.查看API文档; 2.需要导入包: import java.util.Scanner; 3.Scanner的实例化; 4.调用Scanner类的相关方法, 来获取指定的变量。
代码演示：
这里有个疑问：每次运行输出sout语句，光标不能直接换行的哟。能解不？
package com.rucoding.d5;
import java.util.Scanner;
public class ScannerDemo01 {
public static void main(String[] args) {
//声明一个Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的幸运数字: ");
int i = scanner.nextInt();//nextInt()方法接收的是数字类型
System.out.println("你输入的幸运数字为：" + i);
//录入大一新生的基本信息
System.out.println("请输入你的姓名：");
String stuName = scanner.next();
System.out.println("你输入的姓名为：" + stuName);
System.out.println("请输入你的年龄：");
int stuAge = scanner.nextInt();
System.out.println("你输入的年龄为：" + stuAge);
System.out.println("请输入你的体重：");
double stuWeight = scanner.nextDouble();
System.out.println("你输入的体重为：" + stuWeight);
System.out.println("请选择你单身与否？（true(是)/false(否)）");
boolean stuIsSingle = scanner.nextBoolean();
System.out.println("你选择的是：" +stuIsSingle);
//char类型的获取, Scanner类没有提供相应的方法, 只能获取一个字符串
System.out.println("请输入你的性别：（男/女）");
String stuSex = scanner.next();
char stuGender = stuSex.charAt(0);
System.out.println("你输入的性别属性为：" + stuGender);
}
}
6、分支结构语句练习2
代码演示1：
package com.rucoding.d5;
import java.util.Scanner;
public class IfelseDemo02 {
public static void main(String[] args) {
//分支结构语句if else-if else的练习
//声明Scanner类
Scanner scanner = new Scanner(System.in); //接收键盘的输入System.in
System.out.println("请输入岳小鹏的数学成绩：");
int stuScore = scanner.nextInt();
if(stuScore == 100){
System.out.println("岳小鹏的数学成绩为：" + stuScore + ",奖励一辆BMW");
}else if(stuScore > 80 && stuScore <= 99){
System.out.println("岳小鹏的数学成绩为：" + stuScore + ",奖励一台iphone xs max");
}else if(stuScore >= 60 && stuScore <= 80){
System.out.println("岳小鹏的数学成绩为：" + stuScore + ",奖励一个iPad");
}else if(stuScore < 0 || stuScore > 100){
System.out.println("输入的数字有误,请检查！");
}else{
System.out.println("不及格, 什么奖励也没有");
}
}
}
7、分支结构&switch分支
switch - case 结构：
注意： switch-case 结构中的表达式, 只能是如下的六种数据类型之一: byte、short、char、int、枚举类型(JDK5.0)、String类型(JDK7.0) 不能是: boolean、long、float、double类型。
温馨Tip：以下练习题目，可自由安排时间，比如是每日一题，练练手。
练习1代码演示：
package com.rucoding.d5;
public class SwitchCaseDemo01 {
public static void main(String[] args) {
//分支结构之二: switch-case结构
//说明:
//①.根据switch表达式的值, 依次匹配各个case的值,一旦匹配成功,则进入对应的case语句,执行相关语句。
//②.当调用完执行的语句后,则仍然继续向下执行其他的case语句,直到遇见break关键字或末尾结束为止。
//③.break关键字，可以使用在switch-case语句中，表示一旦执行遇到该关键字，就会跳出switch-case结构。
//④.switch-case 结构中的表达式, 只能是如下的六种数据类型之一: byte、short、char、int、枚举类型(JDK5.0)、String类型(JDK7.0)! 不能是: boolean、long、float、double类型
//⑤.case之后声明的是常量，不能声明范围。
//⑥.break关键字是可选的。
//⑦.default：相当于if-else的else default结构是可选的，而且位置是灵活的。
//switch-case可以接受的表达式 int类型
int num = 2;
switch(num){
case 0:
System.out.println("Zero");
case 1:
System.out.println("One");
case 2:
System.out.println("Two");
break;//此处如果不加break,那么遇到case 2执行的时候,会继续执行其他case语句,直到遇见break或者末尾字节结束才会跳出
case 3:
System.out.println("Three");
break;
case 4:
System.out.println("Four");
break;
case 5:
System.out.println("Five");
break;
default:
System.out.println("Other...");
break;
}
//switch-case不能接收的表达式类型，比如boolean类型。
boolean isOk = true;
switch(isOk){ //无法接收boolean类型的表达式 ,无法通过编译。
case true:
System.out.println("Ok");
break;
case false:
System.out.println("Not Ok");
break;
default:
System.out.println("信息有误！");
break;
}
//String类型的，自从jdk1.7开始
String season = "spring";
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;
}
}
}
练习2代码演示：
package com.rucoding.d5;
import java.util.Scanner;
public class SwitchCaseDemo02 {
public static void main(String[] args) {
//声明Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("输入小写的字母,会自动转为大写：");
String str = scanner.next();
char lowerWord = str.charAt(0);//获取指定索引位置的值
//
switch(lowerWord){
case 'a':
System.out.println("A");
break;
case 'b':
System.out.println("B");
break;
case 'c':
System.out.println("C");
break;
case 'd':
System.out.println("D");
break;
case 'e':
System.out.println("E");
break;
default:
System.out.println("other...");
break;
}
}
}
练习3代码演示：
package com.rucoding.d5;
public class SwitchCaseDemo03 {
public static void main(String[] args) {
int stuScore = 78;
switch(stuScore / 10){
case 0: //switch-case语句中执行多个相同的语句，可以进行合并操作
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;
default:
System.out.println("输入有误");
break;
}
//优化上述,更优解
switch(stuScore / 60){
case 0:
System.out.println("不合格");
break;
case 1:
System.out.println("合格");
break;
default:
System.out.println("输入有误！");
break;
}
}
}
练习4代码演示：
*/
//利用分支结构switch-case实现
int month = 10;
switch(month){
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("输入月份有误");
break;
}
练习5代码演示：
package com.rucoding.d6;
import java.util.Scanner;
public class SwitchCaseDemo01 {
public static void main(String[] args) {
//声明从键盘接收的Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("请输入合法月份month: ");
int month = scanner.nextInt();
System.out.println("请输入合法日期day: ");
int day = scanner.nextInt();
//定义总变量天数
int sumDays = 0;
switch(month){
// case 1:
// sumDays = day;
// break;
// case 2:
// sumDays = 31 + day;
// break;
// case 3:
// sumDays = 31 + 28 + day;
// case 4:
// sumDays = 31 + 28 + 31 + day;写着写着发现太冗余了,很多都是重复的代码 31 + .. day 一直都在，优化一下
//我们倒着写
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 + "日是第2019年" + sumDays + "天");
}
}
练习5代码演示（升级版）：
package com.rucoding.d6;
import java.util.Scanner;
public class SwitchCaseDemo02 {
public static void main(String[] args) {
//这题是上面练习4的升级， 多了一个年份， 改变了 2月的天数，闰年的2月是29天，平年的2月是28天
//声明一个接收键盘输入的Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("请输入合法的年份Year：");
int year = scanner.nextInt();
System.out.println("请输入合法的年份Month：");
int month = scanner.nextInt();
System.out.println("请输入合法的年份Day：");
int day = scanner.nextInt();
//定义变量 ，总天数
int sumDays = 0;
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:
//判断输入的year年份是否为闰年
if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)){
sumDays += 29;
}else{
sumDays += 28;
}
case 2:
sumDays +=31;
case 1:
sumDays += day;
}
System.out.println(year + "年的" + month + "月" + day + "日是第" + year + "年" + sumDays + "天");
}
}
练习6代码演示：
package com.rucoding.d6;
import java.util.Scanner;
public class SwitchCaseDemo03 {
public static void main(String[] args) {
//声明一个键盘接收Scanner类
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的诞生年份year: ");
int year = scanner.nextInt();
//除以12,取余变量
int num = year % 12;
switch(num){
case 0:
System.out.println("你的生肖为猴");
break;
case 1:
System.out.println("你的生肖为鸡");
break;
case 2:
System.out.println("你的生肖为狗");
break;
case 3:
System.out.println("你的生肖为猪");
break;
case 4:
System.out.println("你的生肖为鼠");
break;
case 5:
System.out.println("你的生肖为牛");
break;
case 6:
System.out.println("你的生肖为虎");
break;
case 7:
System.out.println("你的生肖为兔");
break;
case 8:
System.out.println("你的生肖为龙");
break;
case 9:
System.out.println("你的生肖为蛇");
break;
case 10:
System.out.println("你的生肖为马");
break;
case 11:
System.out.println("你的生肖为羊");
break;
default:
System.out.println("输入信息有误！");
break;
}
}
}
8、循环结构& for 循环（重点）
循环结构描述： 在某些条件满足的条件下，反复执行特定代码的功能。
循环结构的分类：
（1）、for循环
（2）、while循环
（3）、do-while循环
举例图解：
9、循环结构&for循环练习温馨Tip：以下练习题目，可自由安排时间，比如是每日一题，练练手。
练习1代码演示：
package com.rucoding.d5;
public class ForDemo01 {
public static void main(String[] args) {
//for循环
//for循环结构的使用：基本要素：①.初始化条件;②.循环条件;③.循环体部分;④.迭代条件部分。
for(int i=1;i <= 5;i++){
System.out.println("HelloWorld");
}
//练习
int num = 1;
for(System.out.print('a');num <= 3;System.out.print('c'),num++){
System.out.print('b'); //输出结果 abcbcbc
}
System.out.println();
//练习2
//遍历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 + ",偶数个数：" + count);
}
}
练习2代码演示：
package com.rucoding.d5;
public class ForDemo02 {
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(); //遍历完一个数，打印换行操作
}
}
}
练习3代码演示：
package com.rucoding.d6;
import java.util.Scanner;
public class ForDemo01 {
public static void main(String[] args) {
// 分析一下：
//12的约数，1 、2、3、4、6、12 (约束就是能被整除的)
//20的约数，1、2、4、5、10、20
//此时最大的公约数肯定不会超过 最小数那个，即12
//声明一个键盘的接收类Scanner
Scanner scanner = new Scanner(System.in);
System.out.println("请输入合法的正整数m: ");
int m = scanner.nextInt();
System.out.println("请输入合法的正整数n: ");
int n = scanner.nextInt();
//求最大公约数
//判断两个数的最小值
int min = (m < n) ? m : n; //循环条件部分
for(int i=min;i >=1;i--){ //最大不会超过最小那个12，从12开始递减取最大的
if(m % i == 0 && n % i == 0){
System.out.println(m + "和" + n + "的最大公约数为：" + i);
break;
}
}
//求两个数的最小公倍数
//分析一下：
//12和20 的公倍数，范围最大在他们俩的乘积 m*n 即是 12*20 = 240，最小的范围大于最大那个值
//判断两个数的最大值
int max = (m > n) ? m : n;
for(int i=max;i <= m*n;i++){ //循环条件部分
if(i % m == 0 && i % n == 0){
System.out.println("最小的公倍数为：" + i);
break;
}
}
}
}
练习4代码演示：
package com.rucoding.d6;
public class ForDemo02 {
public static void main(String[] args) {
//拆解，先取这个数个位、十位、百位
for(int i=100;i <=999;i++){
int ge = i % 10; //个位
int shi = i % 100 / 10; //十位
int bai = i / 100; //百位
// int result = ge^3 + shi^3 + bai^3; //a^3这样可不行， java中的^符号是来表示"异或" 运算的。
int result = ge*ge*ge + shi*shi*shi + bai*bai*bai;
if(i == result){
System.out.println("水仙花数是：" + i);
}
}
}
}
10、循环结构&while循环
基本语法格式：
①.初始化部分
while(②循环条件部分){
③.循环体部分;
④.迭代部分;
}
执行过程描述: ①-②-③-④-②-③-④-...②-③-④
说明：
(1)、注意不要忘记声明④迭代部分。否则,循环将不能结束，进入死循环。
(2)、for循环和while循环可以互相转换的。
代码演示：
package com.rucoding.d5;
public class WhileDemo01 {
//遍历100以内的偶数,获取所有偶数的和,输出偶数的个数
public static void main(String[] args) {
//改用while循环实现
int sum =0;
int count =0;
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
i++;
}
System.out.println("偶数总和为：" + sum + ",偶数个数为：" + count);
}
}
11、循环结构&do-while循环
语法格式说明：
代码演示：
package com.rucoding.d5;
public class DoWhileDemo01 {
public static void main(String[] args) {
//遍历100以内的所有偶数,并计算所有偶数的和和偶数的个数
int sum =0;
int count =0;
int i = 1;
do{
if(i % 2 == 0){
System.out.println(i);
sum +=i;
count++;
}
i++;
}while(i <= 100);
System.out.println("偶数总和为：" + sum + ",偶数个数为：" + count);
System.out.println("=======================");
int numb = 10; //这里改为12,输出的结果数是一样的（当满足条件运行，输出结果数一致）
while(numb > 10){
System.out.println("while...");
numb--;
}
int numb2 = 10;//这里改为12,输出的是一样的（当满足条件运行，输出结果数一致）
do{
System.out.println("do-while...");
numb2--;
}while(numb2 > 10);
}
}
12、循环结构&关键字break
(1)、break的使用
break语句会终止某个语句块的执行
{
......
break;
......
}
(2)、break语句出现在多层嵌套的语句块中的时候，可以通过标签指明要终止的是哪一层的语句块
label1: { ......
label2: { ......
label3: { ......
break label2;
......
}
}
}
代码演示（break的 “终止” 特征）：
package com.rucoding.d5;
import java.util.Scanner;
public class BreakDemo01 {
//break关键字的作用: 出现break的时候，会跳出整个循环体
public static void main(String[] args) {
//声明Scanner类
Scanner scanner = new Scanner(System.in);
int numZ = 0;
int numF = 0;
//while循环实现
while(true){
System.out.println("请输入合法的整数：");
int num = scanner.nextInt();
if(num > 0){
numZ++;
}else if(num < 0){
numF++;
}else{
break;//跳出整个循环
}
}
System.out.println("输入的正数个数为：" + numZ + ",输入的负数的个数为：" + numF);
//for循环实现
for(;;){
System.out.println("请输入合法的整数：");
int num = scanner.nextInt();
if(num > 0){
numZ++;
}else if(num < 0){
numF++;
}else{
break;//跳出整个循环
}
}
System.out.println("输入的正数个数为：" + numZ + ",输入的负数的个数为：" + numF);
}
}
代码演示（break的 “标签label终止” 特征）：
package com.rucoding.d6;
public class BreakLableDemo01 {
public static void main(String[] args) {
//演示一下break的标签功能
label:for(int i = 1;i < 3;i++){
for(int j = 1;j < 5;j++){
if(j == 4){
// break;
break label; //break lable直接结束掉外层循环，终止程序。
// continue label; //下面【13要点】会提及
}
System.out.print(j);
}
System.out.println("for lable..."); //break外层循环后，这里不会被打印了。
}
}
}
13、循环结构&关键字continue
continue语句 (1)、continue只能使用在循环结构中; (2)、continue语句用于跳过其所在循环语句的一次执行，继续执行下一次循环; (3)、continue语句出现在多层嵌套循环的语句体时，可以通过标签指明要跳过的是哪一层循环 (重点) : 例题可参考【17、代码4】
代码演示（比较break和continue的区别——重点）：
package com.rucoding.d6;
public class BreakContinueDemo01 {
public static void main(String[] args) {
//演示break和continue的区别
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
// break; //输出123
continue;//输出123567910
// System.out.println();//break、continue后面不能声明执行语句
}
System.out.println(i);
}
System.out.println("============分割线=============");
for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(i % 4 == 0){
// break; //默认跳出包裹此关键字最近的一层循环
continue;
}
System.out.print(j);
}
System.out.println();
}
}
}
小结：
(1)、break只能用于switch语句和循环语句中。 (2)、continue 只能用于循环语句中。 (3)、二者功能类似，但continue是终止本次循环，break是终止本层循环。 (4)、break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。 (5)、标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。14、循环结构&关键字return
return : 并非专门用于结束循环的，它的功能是结束一个方法的。当一个方法执行到一个return语句的时候，这个方法将被结束。 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环内。15、循环结构&嵌套循环（多重循环）
1、嵌套循环(多重循环) (1)、将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for、while、do-while均可以作为外层循环或内层循环。 (2)、实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环条件为false时候，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。 (3)、假设外层循环的次数为m次，内层为n次，则内层循环的实际上执行m*n 次。
代码演示：
package com.rucoding.d6;
public class ForDemo03 {
public static void main(String[] args) {
//输出五个星号
for(int i=1;i <=5;i++){
System.out.print("*");
}
System.out.println();//换行
//输出5行 5个星号
for(int i=1;i <=5;i++){
for(int j=1;j <=5;j++){
System.out.print("*");
}
System.out.println();
}
System.out.println("========分割线=======");
for(int i=1;i <=5;i++){
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
for(int i=1;i <= 5;i++){
for(int j=1;j <= (6-i);j++){
System.out.print("*");
}
System.out.println();
}
System.out.println("========分割线=======");
//分析：
for(int i=1;i <= 5;i++){
for(int j=0;j <= (5-i);j++){
// System.out.print("-"); //上半部分左边的空格， 可以先当做"-"
System.out.print(" ");
}
//控制星号
for(int j=1;j <= i;j++){
System.out.print("*" + " ");
}
System.out.println();
}
//下半部分
for(int i=1;i <= 4;i++){
for(int j=1;j <= i;j++){
// System.out.print("-");//下半部分左边的空格， 可以先当做"-"
System.out.print(" ");
}
//控制星号
for(int j=1;j <= (5-i);j++){
System.out.print(" " + "*" );
}
System.out.println();
}
}
}
16、循环结构&嵌套循环练习1
练习1：打印九九乘法表
代码演示：
package com.rucoding.d6;
public class Print99Demo01 {
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) + " ");
}
System.out.println();
}
}
}
17、循环结构&嵌套循环练习2
练习2：求100000以内的所有质数个数。
代码1：
package com.rucoding.d6;
public class PrimeNumberDemo01 {
//求100000以内的所有质数个数
public static void main(String[] args) {
//分析质数(素数)的特点: 只能被1和它本身整除的自然数。
//最小的质数：2
boolean isFlag = true;//标识是否被除尽，一旦除尽，修改其值
int count = 0;
long startTime = System.currentTimeMillis();//计算程序执行时间
for(int i = 2;i <= 100000;i++){
for(int j = 2;j < i;j++){// 此时j的作用：能否被i整除
//
if(i % j == 0){ //判断i除以j，只要有一个能整除 就设置isFlag为false
isFlag = false;
}
}
if(isFlag == true){
// System.out.println(i);
count++;
}
isFlag = true; //重置flag
}
long endTime = System.currentTimeMillis();
System.out.println("100000以内的质数一共有：" + count + " 个");
System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");
}
}
【代码1】运行结果: 100000以内的质数一共有：9592 个 计算耗时：11000 毫秒
这运行有点费时，得优化。
代码2【针对代码1的优化】：
注意代码出现的 “优化点1”。
package com.rucoding.d6;
public class PrimeNumberDemo02 {
//求100000以内的所有质数个数
public static void main(String[] args) {
//分析质数(素数)的特点: 只能被1和它本身整除的自然数。
//最小的质数：2
boolean isFlag = true;//标识是否被除尽，一旦除尽，修改其值
int count = 0;
long startTime = System.currentTimeMillis();//计算程序执行时间
for(int i = 2;i <= 100000;i++){
for(int j = 2;j < i;j++){// 此时j的作用：能否被i整除
//优化点1：这里假如是非质数i为10,
//那么此时j的循环是2,3,4..9 (第一个2的时候已经满足除尽的，后面就没必要再执行了)
if(i % j == 0){ //判断i除以j，只要有一个能整除 就设置isFlag为false
isFlag = false;
break;//第一个进来满足除尽了，后面的数字没必要再进行一遍整除了。
}
}
if(isFlag == true){
// System.out.println(i);
count++;
}
isFlag = true; //重置flag
}
long endTime = System.currentTimeMillis();
System.out.println("100000以内的质数一共有：" + count + " 个");
System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");
}
}
【代码2】运行结果: 100000以内的质数一共有：9592 个 计算耗时：1078 毫秒
继续观察，发现是还可以进行优化的。
代码3【针对代码2的优化】：
注意代码出现的 “优化点2”。
package com.rucoding.d6;
public class PrimeNumberDemo03 {
//求100000以内的所有质数个数
public static void main(String[] args) {
//分析质数(素数)的特点: 只能被1和它本身整除的自然数。
//最小的质数：2
boolean isFlag = true;//标识是否被除尽，一旦除尽，修改其值
int count = 0;
long startTime = System.currentTimeMillis();//计算程序执行时间
for(int i = 2;i <= 100000;i++){
for(int j = 2;j <= Math.sqrt(i);j++){// 此时j的作用：能否被i整除
//优化点2：这里的循环条件部分(j < i) ,范围可以缩减，刚开始考虑的i/2，缩减了一半，后面再观察考虑一下，开根号可以大大缩减，实在秒啊！
//优化点1：这里假如是非质数i为10,
//那么此时j的循环是2,3,4..9 (第一个2的时候已经满足除尽的，后面就没必要再执行了)
if(i % j == 0){ //判断i除以j，只要有一个能整除 就设置isFlag为false
isFlag = false;
break;//优化点1：第一个进来满足除尽了，后面的数字没必要再进行一遍整除了。
}
}
if(isFlag == true){
// System.out.println(i);
count++;
}
isFlag = true; //重置flag
}
long endTime = System.currentTimeMillis();
System.out.println("100000以内的质数一共有：" + count + " 个");
System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");
}
}
【代码3】运行结果: 100000以内的质数一共有：9592 个 计算耗时：15 毫秒
继续优化，代码看着不太友好。
代码4【针对以上代码的优化】：
Tip：此处利用了continue标签。
package com.rucoding.d6;
public class PrimeNumberDemo04 {
//求100000以内的所有质数个数
public static void main(String[] args) {
//分析质数(素数)的特点: 只能被1和它本身整除的自然数。
//最小的质数：2
int count = 0;
long startTime = System.currentTimeMillis();//计算程序执行时间
label:for(int i = 2;i <= 100000;i++){
for(int j = 2;j <= Math.sqrt(i);j++){// 此时j的作用：能否被i整除
//
if(i % j == 0){ //判断i除以j，能否除尽
continue label;//可以除尽的话，直接后面不用继续了，跳出当前的循环，继续下一次循环
}
}
//能走到这里， 证明已经是质数了。
count++;
}
long endTime = System.currentTimeMillis();
System.out.println("100000以内的质数一共有：" + count + " 个");
System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");
}
}
【代码4】运行结果: 100000以内的质数一共有：9592 个 计算耗时：13 毫秒
