03 Java 流程控制学习笔记

Java 流程控制

---

一、用户交互 Scanner

1. 通过 Scanner 对象来获取用户输入

基本语法：Scanner s = new Scanner(system.in);
使用前需要导入 'java.util.Scanner' 这个包，( import java.util.Scanner; )
通过 'Scanner' 类的 'next()' 和 'nextLine()' 方法获取输入的字符串，在读取前我们一般需要使用 'hasNext()' 与 'hasNextLine()' 判断是否还有输入的数据

next() ：

• 一定要读取到有效字符后才可以结束输入
• 对输入有效字符之前的空白，会自动将其去掉
• 只有在输入有效字符后，将后面的空白作为分隔符或结束符
• next() 不能得到带有空格的字符串

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        // 创建一个扫描对象，用于接收键盘输入
        Scanner s = new Scanner(System.in);
 
        System.out.println("使用next()方法接收:");    // 提示文字
 
        String str = s.next();  // 使用next()方法接收用户的输入,(输入 Hello World)
        System.out.println("输入的字符串是：" + str);   // 输出刚刚输入的字符串，只会输出 Hello
 
        s.close();  // 凡是属于 IO 流的类如果不关闭会一直占用资源，所以用完就需要关闭
    }
}

nextLine() ：

• 以 Enter 回车为结束符，返回输入回车之前的所有字符
• 可以获得空白

import java.util.Scanner;
public class Demo02 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("使用nextLine()方法接收");
 
        String str = s.nextLine();  // 输入 Hello World
        System.out.println("输入的内容为：" + str);    // 输出 Hello World
 
        s.close();  // 关闭
    }
}

2. Scanner的其他用法

• 指定输入的类型

import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        // 接收键盘输入
        Scanner s = new Scanner(System.in);
        int i = 0;          // 定义一个整数变量
        float f = 0.0f;     // 定义一个小数变量
 
        System.out.println("请输入整数：");
        // 判断是否输入的整数
        if (s.hasNextInt()){        // 如果是整数
            i = s.nextInt();        // 将输入的整数赋值给 i
            System.out.println("整数数据：" + i);
        }
        else {
            System.out.println("输入的不是整数");  // 如果不是整数就执行这句，接着执行下面的语句
        }
 
        System.out.println("请输入小数：");
        // 判断是否输入的小数
        if (s.hasNextFloat()){      // 如果是小数
            f = s.nextFloat();      // 将输入的小数赋值给 f
            System.out.println("小数数据：" + f);
        }
        else {
            System.out.println("输入的不是小数");
        }
 
        s.close();
    }
}

import java.util.Scanner;
public class Demo04 {
    public static void main(String[] args) {
        // 输入多个数字，求和，计算平均值。输入非数字就结束输入并计算结果
        Scanner s = new Scanner(System.in);
        double sum = 0;     // 定义和
        int m = 0;          // 定义输入数字的个数
 
        // 通过循环判断是否有输入数字，并求和，统计个数，直到输入非数字就结束循环
        while (s.hasNextDouble()){      // 输入的是数字，就执行循环
            double x = s.nextDouble();  // 将输入的数字赋值给x
            m = m + 1;      // 计算输入的个数，每输入一个数字，m就加1
            sum = sum + x;  // 对输入的数求和
        }
        System.out.println(m + "个数的和："+ sum);
        System.out.println(m + "个数的平均值：" + sum/m);
        s.close();
    }
}
 

---

二、顺序结构

• 语句之间，从上到下依次运行
• 它是任何一个算法都离不开的基本算法结构

---

三、选择结构

1. if 单选择结构

import java.util.Scanner;
public class Demo05 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入：");
        String str = s.nextLine();
 
        // equals 判断字符串是否相等
        if (str.equals("Hello")){
            System.out.println(str);
        }
        System.out.println("end");
        s.close();
    }
}

2. if 双选择结构

import java.util.Scanner;
public class Demo06 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入成绩");
        double score = s.nextDouble();
        if (score>60){
            System.out.println("及格");
        }
        else{
            System.out.println("不及格");
        }
        s.close();
    }
}

3. if 多选择结构

import java.util.Scanner;
public class Demo07 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入成绩：");
        double score = s.nextDouble();
        if (score<100 && score >= 90){
            System.out.println("A");
        }
        else if (score < 90 && score >= 80){
            System.out.println("B");
        }
        else if (score < 80 && score >= 70) {
            System.out.println("C");
        }
        else if (score < 70 && score >= 60){
            System.out.println("D");
        }
        else if (score < 60 && score >= 0){
            System.out.println("E");
        }
        else {
            System.out.println("成绩不合法");
        }
        s.close();
    }
}

4. if 嵌套选择结构

import java.util.Scanner;
public class Demo08 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        double score = s.nextDouble();
        if (score > 60){
            if (score < 70){
                System.out.println("D");
            }
            else if (score < 80 ){
                System.out.println("C");
            }
            else if (score < 90){
                System.out.println("B");
            }
            else{
                System.out.println("A");
            }
        }
        else{
            System.out.println("E");
        }
        s.close();
    }
}

5. switch 选择结构

• switch case 语句判断一个变量与一系列值中的某个值是否相等
• switch 语句中的变量类型可以是：byte 、short 、int 、char 或 String
• case 标签必须为字符常量或字面量

import java.util.Scanner;
public class Demo09 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int score = s.nextInt();
        switch (score){
            case 90:
                System.out.println("A");
                break;
            case 80:
                System.out.println("B");
                break;
            case 70:
                System.out.println("C");
                break;
            case 60:
                System.out.println("D");
                break;
            default:
                System.out.println("E");
        }
    }
}

---

四、循环结构

1. while 循环

while (条件表达式) { 循环体 }

• 只要条件表达式为 true ，循环就会一直执行下去

public class Demo10 {
    public static void main(String[] args) {
        // 计算1 - 100之和
        int i = 0;
        int sum = 0;
        while (i <= 100){
            sum = sum + i;
            i++;
        }
        System.out.println(sum);    // 输出结构：5050
    }
}

2. do ... while 循环

do ... while 循环至少会执行一次
do { 代码块 } while ();

public class Demo11 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do {
            sum = sum + i;
            i++;
        }while(i <= 100);
        System.out.println(sum);
    }
}

3. for 循环

for 循环是支持迭代的一种通用结构，是最有效、最灵活的循环结构
for ( 初始化; 条件表达式; 更新 ) { 代码块 }

public class Demo12 {
    public static void main(String[] args) {
        // 打印1-10
        for (int i=0;i<=10;i++){
            System.out.println(i);
        }
    }
}

计算 0-100 之间奇数和偶数的和

public class Demo13 {
    public static void main(String[] args) {
        // 计算 0-100 之间奇数和偶数的和
        int oddSum = 0;
        int evenSum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i%2 != 0){    // 判断是否为奇数
                oddSum = oddSum + i ;
            }
            else{
                evenSum = evenSum + i;
            }
        }
        System.out.println(oddSum);
        System.out.println(evenSum);
    }
}

输出 1 - 1000 之间能被5整除的数，每行输出3个

public class Demo14 {
    public static void main(String[] args) {
        // 输出 1 - 1000 之间能被5整除的数，每行输出3个
        for (int i = 1; i <= 1000; i++) {
            if (i%5==0){        // 判断是否被5整除
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0){    // 判断被5整数，且被3整除
                System.out.print("\n");     // 等同于System.out.println();（换行输出）
            }
        }
    }
}

打印九九乘法表：

public class Demo15 {
    public static void main(String[] args) {
        // 打印 九九乘法表
        for (int i=1;i<=9;i++){     // 行
            for (int j=1;j<=i;j++){     // 列
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();   // 换行，等同于System.out.print("\n")
        }
    }
}

4. 增强型 for 循环

主要用于数组或集合
for ( 声明语句 ：表达式) { 代码块 }

• 申明语句：申明新的局部变量，该变量的类型必须和数组元素的类型一致，其作用域限定在循环体内，其值与此时数组元素的值相等。
• 表达式：是要访问的数组名，或者是返回值为数组的方法。

public class Demo16 {
    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50};   // 定义一个数组
        // 输出数组元素
        for (int i=0;i<5;i++){
            System.out.println(numbers[i]);
        }
        // 使用增强型for循环输出数组元素
        for (int x:numbers){
            System.out.println(x);
        }
    }
}

---

五、break & continue

• 'break' 在任何循环语句的主体部分，均可用 'break' 控制循环的流程，用于强行退出循环。
• 'continue' 用在循环语句中，用于终止某次循环，跳过本次循环体中未执行的语句，接着下一次循环。

public class Demo17 {
    public static void main(String[] args) {
        int i = 0;
        while (i<100) {
            i++;
            if (i == 30) {
                break;      // i=30，结束循环
            }
            if (i % 10 == 0) {
                continue;       // i是10个倍数，不执行本次循环后面的语句
            }
            System.out.println(i);
        }
    }
}

---

六、练习

打印一个三角形

public class Demo18 {
    public static void main(String[] args) {
        // 打印一个三角形（5行）
        for (int i=1;i<=5;i++){     // 打印5行
            // 打印空格，每行减少一个空格,输出左侧倒置空白三角
            for (int j=5;j>=i;j--){
                System.out.print(" ");  // 注意不是println
            }
            // 打印星号，每行多一个，可以输出三角形左侧部分
            for (int k=1;k<=i;k++){
                System.out.print("*");  // 注意不是println
            }
            // 继续打印星号，从第2行开始，每行多一个
            for (int m=2;m<=i;m++){
                System.out.print("*");  // 注意不是println
            }
            System.out.println();   // 执行一次循环，换行
        }
    }
}

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