第二阶段：流程控制与数组

---

八、条件判断

程序默认按代码书写顺序从上往下依次执行，称为 顺序结构。

public class SequenceDemo {
    public static void main(String[] args) {
        System.out.println("第一行");
        System.out.println("第二行");
        System.out.println("第三行");
    }
}

选择语句（分支结构）：根据条件表达式的值选择执行不同的代码路径。

8.1 if-else 分支

基本格式

if (条件表达式) {
    // 条件为 true 时执行
}

if (条件表达式) {
    // 条件为 true 时执行
} else {
    // 条件为 false 时执行
}

if (条件1) {
    // 条件1 为 true 时执行
} else if (条件2) {
    // 条件1 为 false 且 条件2 为 true 时执行
} else {
    // 以上条件均不满足时执行
}

案例：判断两个数的大小关系

import java.util.Scanner;

public class IfElseDemo {
    public static void main(String[] args) {
        System.out.println("请输入第一个数");
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        System.out.println("请输入第二个数");
        int b = scanner.nextInt();

        if (a == b) {
            System.out.println("两个数相等");
        } else if (a > b) {
            System.out.println("第一个数大于第二个数");
        } else {
            System.out.println("第一个数小于第二个数");
        }
        scanner.close();
    }
}

三目运算符（三元运算符）

数据类型 变量 = 条件表达式 ? 值1 : 值2;
// 条件为 true → 取 值1，否则取 值2

public class TernaryDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int max = (a > b) ? a : b;  // 取较大值
        System.out.println("较大值是：" + max);
    }
}

8.2 switch-case 分支

用于多路判断，JDK 7 开始支持 String 类型判断，JDK 14+ 支持箭头表达式。

传统语法

switch (表达式) {
    case 常量值1:
        语句体1;
        break;
    case 常量值2:
        语句体2;
        break;
    // ...
    default:
        默认语句体;
        break;
}

执行流程：

1. 计算出表达式的值
2. 与 case 依次比较，匹配则执行对应语句
3. 遇到 break 则结束 switch
4. 所有 case 都不匹配则执行 default

注意事项：

• case 穿透：没有 break 会继续向下执行
• default 用于兜底，可放在任意位置

案例：根据数字输出星期

public class SwitchDemo {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            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;
            default: System.out.println("输入错误"); break;
        }
    }
}

案例：利用穿透判断季节

public class SeasonDemo {
    public static void main(String[] args) {
        int month = 3;
        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("输入错误");
        }
    }
}

JDK 14+ 箭头语法（补充）

switch (day) {
    case 1 -> System.out.println("星期一");
    case 2 -> System.out.println("星期二");
    case 3 -> System.out.println("星期三");
    default -> System.out.println("输入错误");
}

// 作为表达式返回值
String result = switch (day) {
    case 1 -> "星期一";
    case 2 -> "星期二";
    default -> "未知";
};

---

九、循环结构

循环：重复执行某些固定功能，当条件不满足时结束。

9.1 for 循环

基本格式

for (初始化赋值; 条件判断; 再求值参数) {
    循环体;
}

执行流程：

第1次：初始化赋值 → 条件判断(true) → 循环体 → 再求值参数
第2次：            条件判断(true) → 循环体 → 再求值参数
第n次：            条件判断(false) → 跳出循环

public class ForDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("hello world - " + i);
        }
    }
}

for-each（增强 for 循环）

适合遍历数组或集合：

int[] arr = {1, 2, 3, 4, 5};
for (int i : arr) {
    System.out.println(i);
}

案例：冒泡排序

public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] arr = {133, 24, 3, 644, 54, 563, 75, 82, 94, 10};
        // 外层循环控制比较轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // 内层循环控制每轮比较次数
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for (int j : arr) {
            System.out.print(j + " ");
        }
    }
}

9.2 while 循环

格式

while (条件表达式) {
    循环体;
    再求值参数;
}

只要表达式的值为 true 就会一直执行循环体，注意避免死循环。

public class WhileDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i < 10) {
            System.out.println("hello world");
            i++;
        }
    }
}

9.3 do-while 循环

格式

do {
    循环体;
    再求值参数;
} while (条件表达式);

特点：先执行一次循环体，再进行条件判断。因此至少执行一次。

public class DoWhileDemo {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("第 " + i + " 次执行");
            i++;
        } while (i < 3);
    }
}

9.4 三种循环对比

循环类型	执行时机	适用场景
for	先判断后执行	最常用，已知循环次数
while	先判断后执行	条件控制，可能一次都不执行
do-while	先执行后判断	至少需要执行一次

9.5 break 与 continue（补充）

关键字	作用
break	结束当前循环，跳出循环体
continue	跳过本次循环剩余语句，进入下一次循环

public class BreakContinueDemo {
    public static void main(String[] args) {
        // break：提前结束循环
        for (int i = 0; i < 10; i++) {
            if (i == 5) break;    // i=5 时跳出循环
            System.out.print(i);   // 输出: 01234
        }

        System.out.println();

        // continue：跳过本次循环
        for (int i = 0; i < 5; i++) {
            if (i == 2) continue; // i=2 时跳过，不打印
            System.out.print(i);   // 输出: 0134
        }
    }
}

带标签的 break（补充）

用于跳出嵌套循环：

outer:  // 标签
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break outer;  // 直接跳出外层循环
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}

---

十、数组

10.1 前言

变量只能存储一个数据，新数据进来会替换旧数据。需要存储多个数据时，就需要 数组。

// 不使用数组：定义 4 个变量
int score1 = 67;
int score2 = 75;
int score3 = 88;
int score4 = 92;
int sum = score1 + score2 + score3 + score4;

数组的概念：

• 数组是一种引用数据类型
• 数组是有序数据的集合
• 数组中的每个元素类型必须一致
• 数组一旦创建，长度不可改变

10.2 声明数组

// 推荐格式
数据类型[] 数组名称;

// 也可（不推荐，可读性差）
数据类型 数组名称[];

boolean[] arr1;
int[] arr2;
double[] arr3;
char[] arr4;
// System.out.println(arr2); // 局部变量未初始化，不能使用

10.3 初始化数组

方式一：静态初始化（指定元素）

// 简化格式（常用）
int[] arr1 = {100, 200, 300};
double[] arr2 = {1.1, 2.2, 3.3, 4.4};
char[] arr3 = {'福', '建', '国', '科'};

// 标准格式
int[] arr4 = new int[]{1, 2, 3};  // 可拆分为两步

简化格式不能分两步写：int[] arr; arr = {1,2,3}; ❌

方式二：动态初始化（指定长度）

数据类型[] 数组名称 = new 数据类型[长度];

int[] arr5 = new int[4];  // 长度为4，默认值全为 0
arr5[0] = 10;             // 赋值
arr5[1] = 20;

默认值：

数据类型	默认值
int（整数）	0
double（浮点）	0.0
boolean	false
char	'\u0000'（空字符）
引用类型	null

10.4 数组的使用

public class ArrayUseDemo {
    public static void main(String[] args) {
        int[] arr1 = {100, 200, 300};
        char[] arr2 = {'福', '建', '国', '科'};

        System.out.println("arr1 的第二个值：" + arr1[1]);  // 200
        System.out.println("arr1 的长度：" + arr1.length);    // 3

        System.out.println("arr2 的第一个值：" + arr2[0]);  // 福
        System.out.println("arr2 的长度：" + arr2.length);    // 4
    }
}

下标（索引）：

• 从 0 开始
• 最大值为 数组长度 - 1
• 访问越界会抛出 ArrayIndexOutOfBoundsException

10.5 数组的遍历

int[] arr = {1, 2, 3, 4};

// 方式一：下标遍历（for）
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

// 方式二：增强 for（for-each）
for (int v : arr) {
    System.out.println(v);
}

// 方式三：快速打印
import java.util.Arrays;
System.out.println(Arrays.toString(arr));  // [1, 2, 3, 4]

10.6 多维数组

多维数组本质上是"数组的数组"。

声明与初始化

// 静态初始化
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 动态初始化
int[][] arr = new int[3][4];  // 3行4列

// 不规则数组
int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[4];
jagged[2] = new int[3];

遍历

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

10.7 Arrays 工具类（补充）

java.util.Arrays 提供了丰富的数组操作工具方法：

import java.util.Arrays;

int[] arr = {5, 3, 1, 4, 2};

// 排序
Arrays.sort(arr);                      // [1, 2, 3, 4, 5]

// 二分查找（需先排序）
int index = Arrays.binarySearch(arr, 3);  // 返回 2

// 拷贝
int[] copy = Arrays.copyOf(arr, 10);      // 扩容至 10，多余补 0
int[] range = Arrays.copyOfRange(arr, 1, 4);  // [2, 3, 4]

// 填充
Arrays.fill(arr, 0);                    // 全部填充为 0

// 比较
int[] arrA = {1, 2, 3};
int[] arrB = {1, 2, 3};
System.out.println(Arrays.equals(arrA, arrB));  // true

// 转字符串
System.out.println(Arrays.toString(arr));   // 格式化输出

10.8 数组常见操作（补充）

数组拷贝（System.arraycopy）

int[] src = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(src, 0, dest, 0, src.length);
// 参数：源数组, 源起始, 目标数组, 目标起始, 长度

数组转 List

String[] strArr = {"A", "B", "C"};
List<String> list = Arrays.asList(strArr);  // 返回的 List 不可增删

查找最大值

int[] arr = {3, 7, 2, 9, 5};
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) max = arr[i];
}
System.out.println("最大值：" + max);

---

第二阶段小结：本阶段学习了顺序结构、条件判断（if-else、switch-case）、三种循环结构（for、while、do-while）以及数组的声明、初始化、遍历和常用操作。流程控制和数组是编写复杂逻辑的基础，建议通过大量练习来巩固。