• java基础知识之流程控制

    流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

    程序设计中规定三种流程结构

    • 顺序结构：程序从上到下逐行地执行，中间没有任何判断和跳转
    • 分支结构：根据条件，选择性地执行某段代码，有if…else和switch-case两种分支语句
    • 循环结构：根据循环条件，重复性的执行某段代码，有for、while、do-while三种循环语句（JDK5.0 提供了foreach循环，方便的遍历集合、数组元素 ）

    一，顺序结构 

    顺序结构就是程序从上到下逐行地执行。表达式语句都是顺序执行的。并且上一行对某个变量的修改对下一行会产生影响。

    例子：

    1. public class StatementTest{
    2. 	public static void main(String[] args){
    3. 		int x = 1;
    4. 		int y = 2;
    5. 		System.out.println("x = " + x);		
    6.         System.out.println("y = " + y);	
    7.         //对x、y的值进行修改
    8.         x++;
    9.         y = 2 * x + y;
    10.         x = x * 10;	
    11.         System.out.println("x = " + x);
    12.         System.out.println("y = " + y);
    13.     }
    14. }

    二，分支语句

    1，if-else条件判断

    格式：

    if (条件表达式1) {
          语句块1;
    } else if (条件表达式2) {
          语句块2;
    }
    ...
    }else if (条件表达式n) {
         语句块n;
    } else {
          语句块n+1;
    }

    例子：

    1. public class IfElseTest3 {
    2.     public static void main(String[] args) {
    3.  
    4.         int score = 67;//岳小鹏的期末成绩    
    5.         //写法二：
    6.         // 默认成绩范围为[0,100]
    7.         if(score == 100){
    8.             System.out.println("奖励一辆跑车");
    9.         }else if(score > 80){
    10.             System.out.println("奖励一辆山地自行车");
    11.         }else if(score >= 60){
    12.             System.out.println("奖励环球影城玩一日游");
    13.         }else{
    14.             System.out.println("胖揍一顿");
    15.         }
    16.     }
    17. }
     2，if-else嵌套

    嵌套结构：在if语句块或者else语句块中又包含了另一个条件判断例子：

    例子1： 排序，按照从小到大输出

    1. public static void main(String[] args) {
    2.         int num1 = 25, num2 = 30, num3 = 15;
    3.         if (num1 >= num2) {
    4.             if (num3>=num1) {
    5.                 System.out.println("num2:"+num2+"-"+"num1:"+num1+"-"+"num3:"+num3);
    6.             } else if (num3<=num2) {
    7.                 System.out.println("num3:"+num3+"-"+"num2:"+num2+"-"+"num1:"+num1);
    8.             } else {
    9.                 System.out.println("num2:"+num2+"-"+"num3:"+num3+"-"+"num1:"+num1);
    10.             }
    11.         } else {
    12.             if (num3>=num2) {
    13.                 System.out.println("num1:"+num1+"-"+"num2:"+num2+"-"+"num3:"+num3);
    14.             } else if (num3<=num1) {
    15.                 System.out.println("num3:"+num3+"-"+"num1:"+num1+"-"+"num2:"+num2);
    16.             } else {
    17.                 System.out.println("num1:"+num1+"-"+"num3:"+num3+"-"+"num2:"+num2);
    18.             }
    19.         }
    20.     }

    例子2：指出输出结果

    1. boolean b = true;
    2. //如果写成if(b=false)能编译通过吗？如果能，结果是？
    3. if(b == false) 	 //建议：if(!b)
    4. 	System.out.println("a");
    5. else if(b)
    6. 	System.out.println("b");
    7. else if(!b)
    8. 	System.out.println("c");
    9. else
    10. 	System.out.println("d");
    11.  
    12.  
    13. ///结果：b
    3，switch-case选择结构

    语法格式：

    switch(表达式){
        case 常量值1:
            语句块1;
            //break;
        case 常量值2:
            语句块2;
            //break; 
        // ...
       [default:
            语句块n+1;
            break;
       ]
    }

     执行过程

    • 根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。
    • 执行完此case的执行语句以后，如果遇到break，则跳出switch结构，否则会继续执行当前case之后的其它case中的执行语句（case穿透），直到遇到break或者default跳出语switch-case机构。

     注意事项：

    • switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；

    • case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；

    • 同一个switch语句，所有case子句中的常量值互不相同

    • break语句用来在执行完一个case分支后使程序跳出switch语句块；

      如果没有break，程序会顺序执行到switch结尾；

    • default子句是可选的。同时，位置也是灵活的。当没有匹配的case时，执行default语句。

     例子：

    1. public class SwitchCaseTest1 {
    2.     public static void main(String args[]) {
    3.         int num = 1;
    4. 		switch(num){
    5. 			case 0:
    6. 				System.out.println("zero");
    7. 				break;
    8. 			case 1:
    9. 				System.out.println("one");
    10. 				break;
    11. 			case 2:
    12. 				System.out.println("two");
    13. 				break;
    14. 			case 3:
    15. 				System.out.println("three");
    16. 				break;
    17. 			default:
    18. 				System.out.println("other");
    19. 				//break;
    20. 		}
    21.     }
    22. }

     case穿透性举例：从键盘分别输入年、月、日，判断这一天是当年的第几天

    1. public class SwitchCaseTest04 {
    2.  
    3.     public static void main(String[] args) {
    4.  
    5.         Scanner scanner = new Scanner(System.in);
    6.         System.out.print("请输入year:");
    7.         int year = scanner.nextInt();
    8.  
    9.         System.out.print("请输入month:");
    10.         int month = scanner.nextInt();
    11.  
    12.         System.out.print("请输入day:");
    13.         int day = scanner.nextInt();
    14.  
    15.         //判断这一天是当年的第几天==>从1月1日开始，累加到xx月xx日这一天
    16.         //(1)[1,month-1]个月满月天数
    17.         //(2)单独考虑2月份是否是29天（依据是看year是否是闰年）
    18.         //(3)第month个月的day天
    19.  
    20.         //声明一个变量days，用来存储总天数
    21.         int sumDays = 0;
    22.  
    23.         //累加[1,month-1]个月满月天数
    24.         switch (month) {
    25.             case 12:
    26.                 //累加的1-11月
    27.                 sumDays += 30;//这个30是代表11月份的满月天数
    28.                 //这里没有break，继续往下走
    29.             case 11:
    30.                 //累加的1-10月
    31.                 sumDays += 31;//这个31是代表10月的满月天数
    32.                 //这里没有break，继续往下走
    33.             case 10:
    34.                 sumDays += 30;//9月
    35.             case 9:
    36.                 sumDays += 31;//8月
    37.             case 8:
    38.                 sumDays += 31;//7月
    39.             case 7:
    40.                 sumDays += 30;//6月
    41.             case 6:
    42.                 sumDays += 31;//5月
    43.             case 5:
    44.                 sumDays += 30;//4月
    45.             case 4:
    46.                 sumDays += 31;//3月
    47.             case 3:
    48.                 sumDays += 28;//2月
    49.                 //在这里考虑是否可能是29天
    50.                 if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
    51.                     sumDays++;//多加1天
    52.                 }
    53.             case 2:
    54.                 sumDays += 31;//1月
    55.             case 1:
    56.                 sumDays += day;//第month月的day天
    57.         }
    58.  
    59.         //输出结果
    60.         System.out.println(year + "年" + month + "月" + day + "日是这一年的第" + sumDays + "天");
    61.  
    62.         scanner.close();
    63.     }
    64. }

    注：判断一年是否是闰年的标准：
       1）可以被4整除，但不可被100整除
          或
       2）可以被400整除 

     例子3：押宝游戏

    随机产生3个1-6的整数，如果三个数相等，那么称为“豹子”，如果三个数之和大于9，称为“大”，如果三个数之和小于等于9，称为“小”，用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了

    • 随机数  Math.random()产生 [0,1)范围内的小数
    • 获取[a,b]范围内的随机整数公式：(int)(Math.random() * (b - a + 1)) + a
    1. import java.util.Scanner;
    2.  
    3. public class SwitchCaseExer5 {
    4.     public static void main(String[] args) {
    5.         //1、随机产生3个1-6的整数
    6.         int a = (int)(Math.random()*6 + 1);
    7.         int b = (int)(Math.random()*6 + 1);
    8.         int c = (int)(Math.random()*6 + 1);
    9.  
    10.         //2、押宝
    11.         Scanner input = new Scanner(System.in);
    12.         System.out.print("请押宝（豹子、大、小）：");
    13.         String ya = input.next();
    14.         input.close();
    15.  
    16.         //3、判断结果
    17.         boolean result = false;
    18.         //switch支持String类型
    19.         switch (ya){
    20.             case "豹子": result = a == b && b == c; break;
    21.             case "大": result = a + b + c > 9; break;
    22.             case "小": result = a + b + c <= 9; break;
    23.             default:System.out.println("输入有误！");
    24.         }
    25.  
    26.         System.out.println("a,b,c分别是：" + a +"," + b +"," + c );
    27.         System.out.println(result ? "猜中了" : "猜错了");
    28.     }
    29. }

    三，循环语句

    循环结构分类

    • for 循环

    • while 循环

    • do-while 循环

    循环结构 四要素

    • 初始化部分

    • 循环条件部分

    • 循环体部分

    • 迭代部分

    1，for循环

    基本语法

    for (①初始化部分; ②循环条件部分; ④迭代部分)｛
                 ③循环体部分;
    ｝

     说明：

    • for(;;)中的两个；不能多也不能少

    • ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔

    • ②循环条件部分为boolean类型表达式，当值为false时，退出循环

    • ④可以有多个变量更新，用逗号分隔

     例子1：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如： 153 = 1*1*1 + 3*3*3 + 5*5*5

    1. public class ForTest4 {
    2. 	public static void main(String[] args) {
    3. 		//定义统计变量，初始化值是0
    4. 		int count = 0;
    5. 		
    6. 		//获取三位数，用for循环实现
    7. 		for(int x = 100; x < 1000; x++) {
    8. 			//获取三位数的个位，十位，百位
    9. 			int ge = x % 10;
    10. 			int shi = x / 10 % 10;
    11. 			int bai = x / 100;
    12. 			
    13. 			//判断这个三位数是否是水仙花数，如果是，统计变量++
    14. 			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
    15.                 System.out.println("水仙花数：" + x);
    16. 				count++;
    17. 			}
    18. 		}
    19. 		
    20. 		//输出统计结果就可以了
    21. 		System.out.println("水仙花数共有"+count+"个");
    22. 	}
    23. }
    24.  
    25. 结果：
    26. 153
    27. 370
    28. 371
    29. 407
    30. 水仙花数为:4

    例子2：输入两个正整数m和n，求其最大公约数和最小公倍数。

    1. public class ForTest5 {
    2.     public static void main(String[] args) {
    3.         //需求1：最大公约数
    4.         int m = 12, n = 20;
    5.         //取出两个数中的较小值
    6.         int min = (m < n) ? m : n;
    7.  
    8.         for (int i = min; i >= 1; i--) {//for(int i = 1;i <= min;i++){
    9.  
    10.             if (m % i == 0 && n % i == 0) {
    11.                 System.out.println("最大公约数是：" + i); //公约数
    12.  
    13.                 break; //跳出当前循环结构
    14.             }
    15.         }
    16.  
    17.  
    18.         //需求2：最小公倍数
    19.         //取出两个数中的较大值
    20.         int max = (m > n) ? m : n;
    21.  
    22.         for (int i = max; i <= m * n; i++) {
    23.  
    24.             if (i % m == 0 && i % n == 0) {
    25.  
    26.                 System.out.println("最小公倍数是：" + i);//公倍数
    27.  
    28.                 break;
    29.             }
    30.         }
    31.  
    32.     }
    33. }
    2，while循环

    语法格式

    ①初始化部分
    while(②循环条件部分)｛
        ③循环体部分;
        ④迭代部分;
    }

     说明：

    • for循环与while循环的区别：初始化条件部分的作用域不同。

     举例1：猜数字游戏，随机生成一个100以内的数，猜这个随机数是多少？

    从键盘输入数，如果大了，提示大了；如果小了，提示小了；如果对了，就不再猜了，并统计一共猜了多少次。

    提示：生成一个[a,b] 范围的随机数的方式：(int)(Math.random() * (b - a + 1) + a)

    1. public class GuessNumber {
    2.     public static void main(String[] args) {
    3.         //获取一个随机数
    4.         int random = (int) (Math.random() * 100) + 1;
    5.  
    6.         //记录猜的次数
    7.         int count = 1;
    8.  
    9.         //实例化Scanner
    10.         Scanner scan = new Scanner(System.in);
    11.         System.out.println("请输入一个整数(1-100):");
    12.         int guess = scan.nextInt();
    13.  
    14.         while (guess != random) {
    15.  
    16.             if (guess > random) {
    17.                 System.out.println("猜大了");
    18.             } else if (guess < random) {
    19.                 System.out.println("猜小了");
    20.             }
    21.  
    22.             System.out.println("请输入一个整数(1-100):");
    23.             guess = scan.nextInt();
    24. 			//累加猜的次数
    25.             count++;
    26.  
    27.         }
    28.  
    29.         System.out.println("猜中了！");
    30.         System.out.println("一共猜了" + count + "次");
    31.     }
    32. }

     例子2：折纸珠穆朗玛峰，世界最高山峰是珠穆朗玛峰，它的高度是8848.86米，假如我有一张足够大的纸，它的厚度是0.1毫米。
    请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

    1. public class ZFTest {
    2.     public static void main(String[] args) {
    3.         //定义一个计数器，初始值为0
    4.         int count = 0;
    5.  
    6.         //定义珠穆朗玛峰的高度
    7.         int zf = 8848860;//单位：毫米
    8.  
    9.         double paper = 0.1;//单位：毫米
    10.  
    11.         while(paper < zf){
    12.             //在循环中执行累加，对应折叠了多少次
    13.             count++;
    14.             paper *= 2;//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
    15.         }
    16.  
    17.         //打印计数器的值
    18.         System.out.println("需要折叠：" + count + "次");
    19.         System.out.println("折纸的高度为" + paper/1000 + "米，超过了珠峰的高度");
    20.     }
    21. }
    22. //结果：
    23. //需要折叠：27次
    24. //折纸的高度为13421.7728米，超过了珠峰的高度
    3,do-while 循环

    语法格式

    ①初始化部分;
    do{
        ③循环体部分
        ④迭代部分
    }while(②循环条件部分); 

    执行过程：①-③-④-②-③-④-②-③-④-...-②

    说明：

    • 结尾while(循环条件)中循环条件必须是boolean类型

    • do{}while();最后有一个分号

    • do-while结构的循环体语句是至少会执行一次，这个和for和while是不一样的

    • 循环的三个结构for、while、do-while三者是可以相互转换的。

     例子1：遍历1-100的偶数，并计算所有偶数的和、偶数的个数（累加的思想）

    1. class DoWhileTest1 {
    2. 	public static void main(String[] args) {
    3.  
    4. 		//遍历1-100的偶数，并计算所有偶数的和、偶数的个数（累加的思想）
    5. 		//初始化部分
    6. 		int num = 1;
    7. 		int sum = 0;//记录1-100所有的偶数的和
    8. 		int count = 0;//记录1-100之间偶数的个数
    9. 		do{
    10. 			//循环体部分
    11. 			if(num % 2 == 0){
    12. 				System.out.println(num);
    13. 				sum += num;
    14. 				count++;
    15. 			}
    16. 			num++;//迭代部分
    17. 		}while(num <= 100); //循环条件部分
    18.  
    19.  
    20. 		System.out.println("偶数的总和为：" + sum);
    21. 		System.out.println("偶数的个数为：" + count);
    22. 	}
    23. }
    4，无限循环

    语法格式

    • 最简单"无限"循环格式：while(true) , for(;;)

    例子：

    1. public class EndlessFor1 {
    2.     public static void main(String[] args) {
    3.         for (;;){
    4.             System.out.println("我爱你！");
    5.         }
    6. //        System.out.println("end");//永远无法到达的语句，编译报错
    7.     }
    8. }
    9.  
    10. public class EndlessFor2 {
    11.     public static void main(String[] args) {
    12.         for (; true;){ //条件永远成立，死循环
    13.             System.out.println("我爱你！");
    14.         }
    15.     }
    16. }

     5，嵌套循环

    • 所谓嵌套循环，是指一个循环结构A的循环体是另一个循环结构B。
    • 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次
    • 技巧：从二维图形的角度看，外层循环控制行数，内层循环控制列数

    例子1：九九乘法表

    1. public class ForForTest5 {
    2.     public static void main(String[] args) {
    3.         for (int i = 1; i <= 9; i++) {
    4.             for (int j = 1; j <= i; j++) {
    5.                 System.out.print(i + "*" + j + "=" + (i * j) + "\t");
    6.             }
    7.             System.out.println();
    8.         }
    9.     }
    10. }

    四，关键字break和continue的使用

    •  break：一旦执行，就结束(或跳出)当前循环结构
    • continue：一旦执行，就结束(或跳出)当次循环结构
     1，带标签的使用
    • break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

    • continue语句出现在多层嵌套的循环语句体中时，也可以通过标签指明要跳过的是哪一层循环。

    • 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面

    例子1：

    1. class BreakContinueTest2 {
    2. 	public static void main(String[] args) {
    3. 		lable:for(int i = 1;i <= 4;i++){
    4. 		
    5. 			for(int j = 1;j <= 10;j++){
    6. 				if(j % 4 == 0){
    7. 					//break lable;
    8. 					continue lable;
    9. 				}
    10. 				System.out.print(j);
    11. 			}
    12. 			System.out.println();
    13. 		}
    14. 	}
    15. }

    例子2：找出100以内所有的素数（质数）？100000以内的呢？

    目的：不同的代码的实现方式，可以效率差别很大。

    分析：素数（质数）：只能被1和它本身整除的自然数。 ---> 从2开始，到这个数-1为止，此范围内没有这个数的约数。则此数是一个质数。 比如：2、3、5、7、11、13、17、19、23、.  

    方式一：

    1. class PrimeNumberTest {
    2. 	public static void main(String[] args) {
    3. 		
    4. 		
    5. 		//boolean isFlag = true; //用于标识i是否被除尽过
    6.  
    7. 		long start = System.currentTimeMillis(); //记录当前时间距离1970-1-1 00:00:00的毫秒数
    8. 			
    9. 		int count = 0;//记录质数的个数
    10.  
    11.  
    12. 		for(int i = 2;i <= 100000;i++){  //i
    13.  
    14. 			boolean isFlag = true; //用于标识i是否被除尽过
    15. 		
    16. 			for(int j = 2;j <= i - 1;j++){
    17. 				
    18. 				if(i % j == 0){ //表明i有约数
    19. 					isFlag = false;
    20. 				}
    21. 			
    22. 			}
    23.  
    24. 			//判断i是否是质数
    25. 			if(isFlag){ //如果isFlag变量没有给修改过值，就意味着i没有被j除尽过。则i是一个质数
    26. 				//System.out.println(i);
    27. 				count++;
    28. 			}
    29.  
    30. 			//重置isFlag
    31. 			//isFlag = true;
    32. 		
    33. 		}
    34.  
    35. 		long end = System.currentTimeMillis();
    36. 		System.out.println("质数的个数为：" + count);
    37. 		System.out.println("执行此程序花费的毫秒数为：" + (end - start)); //16628
    38.  
    39. 	}
    40. }

     方式二：优化

    1. class PrimeNumberTest1 {
    2. 	public static void main(String[] args) {
    3. 		
    4. 		long start = System.currentTimeMillis(); //记录当前时间距离1970-1-1 00:00:00的毫秒数
    5.  
    6. 		int count = 0;//记录质数的个数
    7.  
    8. 		for(int i = 2;i <= 100000;i++){  //i
    9.  
    10. 			boolean isFlag = true; //用于标识i是否被除尽过
    11. 		
    12. 			for(int j = 2;j <= Math.sqrt(i);j++){ //优化2：将循环条件中的i改为Math.sqrt(i)
    13. 				
    14. 				if(i % j == 0){ //表明i有约数
    15. 					isFlag = false;
    16. 					break;//优化1：主要针对非质数起作用
    17. 				}
    18. 			
    19. 			}
    20.  
    21. 			//判断i是否是质数
    22. 			if(isFlag){ //如果isFlag变量没有给修改过值，就意味着i没有被j除尽过。则i是一个质数
    23. 				//System.out.println(i);
    24. 				count++;
    25. 			}
    26. 		
    27. 		}
    28.  
    29. 		long end = System.currentTimeMillis();
    30. 		System.out.println("质数的个数为：" + count);
    31. 		System.out.println("执行此程序花费的毫秒数为：" + (end - start));//1062
    32.  
    33. 	}
    34. }

  • 相关阅读:
    基于全志H3的QT5.12.9移植教程
    JeecgBoot 3.4.3-GA 版本发布，开源免费的企业级低代码平台
    算法的基本概念
    Linux 多进程解决客户端与服务器端通信
    【教学类-09】20221022《动物棋》（数字续写和骰子游戏）（大班主题《动物花花衣》)
    堆--数据流中第K大元素
    函数的极限：如何通过 δ 和 ϵ 来定义一个连续的函数
    如何判断结构体是否相等？能否用 memcmp 函数判断结构体相等？
    云原生之旅 - 10）手把手教你安装 Jenkins on Kubernetes
    Tensorflow的GPU分配方法
  • 原文地址：https://blog.csdn.net/zhouchang111/article/details/133377200