chapter03 流程语句 知识点Note

@TOC

分支结构if-else 和 switch-case

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

switch-case 执行过程：

第1步：根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。

第2步：执行完此case的执行语句以后，
​ 情况1：如果遇到break,则执行break并跳出当前的switch-case结构
​ 情况2：如果没有遇到break，则会继续执行当前case之后的其它case中的执行语句。—> case穿透
​ …
​ 直到遇到break关键字或执行完所有的case及default的执行语句，跳出当前的switch-case结构

使用注意点：

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

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

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

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

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

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

• case语句必须是常量值

// 错误代码 此处case写成了表达式 不再是常量值
int key = 10;
switch(key){
	case key > 0 :
        System.out.println("正数");
        break;
    case key < 0:
        System.out.println("负数");
        break;
    default:
        System.out.println("零");
        break;
}

使用switch-case实现：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

switch(score / 60){
    case 0:
        System.out.println("不及格");
        break;
    case 1:
        System.out.println("及格");
        break;
    default:
        System.out.println("输入的成绩有误");
        break;
}

case穿透 在switch语句中，如果case的后面不写break，将出现穿透现象，也就是一旦匹配成功，不会在判断下一个case的值，直接向后运行，直到遇到break或者整个switch语句结束，执行终止。

Scanner类

1 导包 import java.util.Scanner

2 创建 Scanner类 实例

3 调用Scanner方法 （阻塞式方法）

4 关闭资源 Scanner.close() 避免内存泄漏

在一个类里面 调用多个Scanner 需要将close()方法放在最后面 不然会报错

Exception in thread "main" java.util.NoSuchElementException

​ 当先调用方法A时，此时并不会报错，但你调完方法A再去调方法B时便会标错了，报错为原因是因为：当你在方法A里把扫描器Scanner关掉时，扫描器里的输入流(System.in)也一起关掉了，再调方法B时，虽然重新创建了Scanner类的对象，但输入流(System.in)是无法再次打开的，因此会抛出异常NoSuchElementException。

Scanner.next()方法获取输入 nextInt() nextDouble()可以定义输入类型

Scanner类中 没有char的 类型变量方法 使用next() 后 调取charAt(0)

字符串间的比较equals()方法

循环语句 for循环 do-while循环 while循环 forEach

for循环结构

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

public class ForTest1 {
    public static void main(String[] args) {
        //需求1：控制台输出5行Hello World!
		//写法1：
		//System.out.println("Hello World!");
		//System.out.println("Hello World!");

		//写法2：
		for(int i = 1;i <= 5;i++){
			System.out.println("Hello World!");
		}
    }
}

• for(;;)中的两个；不能多也不能少
• ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
• ②循环条件部分为boolean类型表达式，当值为false时，退出循环
• ④可以有多个变量更新，用逗号分隔

1、我们可以在循环中使用break。一旦执行break，就跳出当前循环结构。

2、小结：如何结束一个循环结构？

​ 结束情况1：循环结构中的循环条件部分返回false

​ 结束情况2：循环结构中执行了break。

3、如果一个循环结构不能结束，那就是一个死循环！我们开发中要避免出现死循环。

while循环

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

class WhileTest1 {
	public static void main(String[] args) {
		
		int i = 1;
		while(i <= 5){
			System.out.println("Hello World!");
			i++;
		}
	}
}

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

• 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。

• for循环和while循环可以相互转换。二者没有性能上的差别。

• 实际开发中，根据具体结构的情况，选择哪个格式更合适、美观。

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

嵌套循环 无限循环

所谓嵌套循环，是指一个循环结构A的循环体是另一个循环结构B。

• 比如，for循环里面还有一个for循环，就是嵌套循环。其中，for ,while ,do-while均可以作为外层循环或内层循环。

• 外层循环：循环结构A

  • 内层循环：循环结构B

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

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

• **技巧：**从二维图形的角度看，外层循环控制行数，内层循环控制列数。

• **开发经验：**实际开发中，我们最多见到的嵌套循环是两层。一般不会出现超过三层的嵌套循环。如果将要出现，一定要停下来重新梳理业务逻辑，重新思考算法的实现，控制在三层以内。否则，可读性会很差。

do-while 循环至少执行一次

while(true) for(; 无限循环 死循环

随机数 Random类

如何产生一个指定范围的随机整数？

1、Math类的random()的调用，会返回一个[0,1)范围的一个double型值

2、Math.random() * 100 —> [0,100)

​ int random = (int)(Math.random() * 100) + 1; 生成一个[1,100]之间的数

​ (int)(Math.random() * 100) —> [0,99]
​ (int)(Math.random() * 100) + 5 ----> [5,104]

3、如何获取[a,b]范围内的随机整数呢？(int)(Math.random() * (b - a + 1)) + a

break 一旦执行，就结束(或跳出)当前循环结构

continue 一旦执行，就结束(或跳出)当次循环结构

// 获取系统当前时间
long time = System.currentTimeMillis();

import java.lang.reflect.Array;

public class PrimeNumber {
    public static void main(String[] args){
        // 找出100以内的质数  1 2 3 5 7 11 13

        // 测试性能
        int count1 = 0;
        int count2 = 0;
        // 获取系统当前时间
        long start = System.currentTimeMillis();
        for(int i = 2; i <= 10000; i++){
            int number = 0;
            for(int j = 2; j < i; j++){
                if(i % j == 0){
                    number++;
                }
            }
            if(number == 0){
                // System.out.print(i + " ");
                count1++;
            }
        }

        System.out.println("count1 = " + count1);
        long end = System.currentTimeMillis();
        System.out.println("时间" + (end - start) + "ms");
        System.out.println();

        long start2 = System.currentTimeMillis();
        for(int i = 2; i <= 10000; i++){
            boolean isPrime = true;

            for(int j = 2; j < i; j++){
                if(i % j == 0){
                    isPrime = false;
                    break;
                }
            }
            if(isPrime){
                // System.out.print(i + " ");
                count2++;
            }   
        }
        System.out.println("count2 = " + count2);
        long end2 = System.currentTimeMillis();
        System.out.println("时间" + (end2 - start2) + "ms");
    }
}

 for(int i = 2; i <= 10000; i++){
            boolean isPrime = true;

            for(int j = 2; j <= Math.sqrt(i); j++){
                if(i % j == 0){
                    isPrime = false;
                    break;
                }
            }
            if(isPrime){
                // System.out.print(i + " ");
                count2++;
            }
        }