数组：一排带编号的格子

数组的静态初始化在声明时直接写出元素：

int[] scores = {88, 92, 75, 60, 95};

int[] 表示“一排 int 格子”。scores 是数组变量名。花括号里是 5 个元素，数组长度就是 5。下标从 0 开始：第 1 个元素是 scores[0]，第 5 个是 scores[4]。scores.length 得到元素个数 5，最后一个元素的下标是 length - 1。

先预测：scores.length 是几？scores[0] 和 scores[4] 分别是什么？scores[5] 能取到吗？

建目录、写 ArrayBasicsDemo.java。同名文件存在时先备份，不覆盖旧内容：

$ source ~/java-practice/env.sh
$ java -version
$ javac -version
$ mkdir -p ~/java-practice/lesson06
$ cd ~/java-practice/lesson06
$ if [ -e ArrayBasicsDemo.java ]; then mv ArrayBasicsDemo.java "ArrayBasicsDemo.java.bak.$(date +%s)"; fi
$ nano ArrayBasicsDemo.java

把下面这个完整文件粘进 nano，按 Ctrl+O 回车保存，再按 Ctrl+X 退出：

public class ArrayBasicsDemo {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 60, 95};
        System.out.println("数组长度：" + scores.length);
        System.out.println("第 1 个：" + scores[0]);
        System.out.println("第 5 个：" + scores[4]);
        System.out.println("最后一个：" + scores[scores.length - 1]);
    }
}

$ ls -l ArrayBasicsDemo.java
$ javac -encoding UTF-8 ArrayBasicsDemo.java
$ java ArrayBasicsDemo

数组长度：5
第 1 个：88
第 5 个：95
最后一个：95

scores.length 是 5，不是 4；下标最大是 4。scores[scores.length - 1] 先算 5 - 1 = 4，再取 scores[4]，所以也是 95。记住这个写法：**最后一个元素的下标永远是 length - 1**。

length 是数组的属性，不带圆括号；写 scores.length() 会编译错误。先记住数组用 length，不要加括号。

如果声明时还不知道每个元素的值，可以先规定长度，让 Java 开好格子：

int[] scores = new int[5];

这叫动态初始化。new int[5] 创建 5 个 int 格子，每个格子先填默认值 0。之后用 scores[0] = 88; 这样的赋值语句逐个写入。数组长度在创建时确定，之后不能改；scores.length 仍然是 5。

new 在这里是“创建数组”的意思。第四单元会用 new 创建对象，那是另一件事；现在只要知道 new int[5] 是按 5 个格子开数组即可。

先预测：刚创建、还没赋值时，scores[0] 是几？写完 5 个值后，scores.length 会变成几？

$ cd ~/java-practice/lesson06
$ if [ -e ArrayFillDemo.java ]; then mv ArrayFillDemo.java "ArrayFillDemo.java.bak.$(date +%s)"; fi
$ nano ArrayFillDemo.java

public class ArrayFillDemo {
    public static void main(String[] args) {
        int[] scores = new int[5];
        System.out.println("默认第 1 个：" + scores[0]);
        scores[0] = 88;
        scores[1] = 92;
        scores[2] = 75;
        scores[3] = 60;
        scores[4] = 95;
        System.out.println("写入后第 1 个：" + scores[0]);
        System.out.println("写入后第 5 个：" + scores[4]);
        System.out.println("长度仍是：" + scores.length);
    }
}

$ javac -encoding UTF-8 ArrayFillDemo.java
$ java ArrayFillDemo

默认第 1 个：0
写入后第 1 个：88
写入后第 5 个：95
长度仍是：5

刚创建时 5 个格子都是 0，所以 scores[0] 打印 0；赋值只改对应格子的值，长度一直是 5。写第 5 个元素要用 scores[4]，不是 scores[5]。

遍历就是“从第一个格子走到最后一个格子”。数组的标准遍历写法：

for (int i = 0; i < scores.length; i++) {
    // 使用 scores[i]
}

i 是下标，从 0 开始；条件是 i < scores.length，不是 i <= scores.length。因为最后一个合法下标是 length - 1，当 i 等于 length 时已经越界。

先预测：下面的循环会打印几行？如果条件写成 i <= scores.length，第 6 次会发生什么？

$ cd ~/java-practice/lesson06
$ if [ -e ArrayTraverseDemo.java ]; then mv ArrayTraverseDemo.java "ArrayTraverseDemo.java.bak.$(date +%s)"; fi
$ nano ArrayTraverseDemo.java

public class ArrayTraverseDemo {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 60, 95};
        for (int i = 0; i < scores.length; i++) {
            System.out.println("scores[" + i + "] = " + scores[i]);
        }
        System.out.println("遍历结束，共 " + scores.length + " 个元素");
    }
}

$ javac -encoding UTF-8 ArrayTraverseDemo.java
$ java ArrayTraverseDemo

scores[0] = 88
scores[1] = 92
scores[2] = 75
scores[3] = 60
scores[4] = 95
遍历结束，共 5 个元素

i 依次取 0、1、2、3、4，scores[i] 就依次是 5 个元素；i 变成 5 时，5 < 5 为 false，循环结束。这里把 i 拼进字符串只是为了看清下标，真正取元素的是 scores[i]。

如果写成 i <= scores.length，i 会走到 5，scores[5] 越界，程序在第 6 次循环时抛异常。**遍历边界记成 i < length，不要背成 i <= length。**

数组的合法下标是 0 到 length - 1。访问这个范围之外的格子，Java 会抛出 ArrayIndexOutOfBoundsException，程序不会返回 0，也不会自动扩容，而是当场停止。

先预测：下面的程序会打印几行？最后一行“这一行不会执行”会出现吗？

$ cd ~/java-practice/lesson06
$ if [ -e ArrayBoundsDemo.java ]; then mv ArrayBoundsDemo.java "ArrayBoundsDemo.java.bak.$(date +%s)"; fi
$ nano ArrayBoundsDemo.java

public class ArrayBoundsDemo {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 60, 95};
        System.out.println("准备读取下标 5");
        System.out.println(scores[5]);
        System.out.println("这一行不会执行");
    }
}

$ javac -encoding UTF-8 ArrayBoundsDemo.java
$ java ArrayBoundsDemo

这段程序会故意失败。标准输出只有第一行：

准备读取下标 5

异常信息走的是标准错误（stderr），不会出现在 output 块里。终端上会看到类似下面的内容（不同 JDK 补丁的措辞可能略有差异，认类名和“下标 5 超出长度 5”即可）：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5

Index 5 out of bounds for length 5 的意思是：长度为 5 的数组，合法下标是 0 到 4，你却要取下标 5。程序在 scores[5] 这一行就停了，后面的“这一行不会执行”没有机会执行。

正确取最后一个元素的写法是先算 length - 1：

$ cd ~/java-practice/lesson06
$ if [ -e ArrayLastDemo.java ]; then mv ArrayLastDemo.java "ArrayLastDemo.java.bak.$(date +%s)"; fi
$ nano ArrayLastDemo.java

public class ArrayLastDemo {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 60, 95};
        int lastIndex = scores.length - 1;
        System.out.println("最后一个下标：" + lastIndex);
        System.out.println("最后一个元素：" + scores[lastIndex]);
    }
}

$ javac -encoding UTF-8 ArrayLastDemo.java
$ java ArrayLastDemo

最后一个下标：4
最后一个元素：95

lastIndex 是 4，scores[4] 合法。不要把 lastIndex 写死成 4；如果数组换成 8 个元素，length - 1 会自动变成 7，写死的 4 就错了。

先看一个容易误判的例子：

int[] first = {10, 20, 30};
int[] second = first;
second[0] = 99;

second = first 不是把 3 个元素复制一份，而是让 second 和 first 指向同一排格子。通过 second[0] 改值，first[0] 也会看到变化，因为两个名字说的是同一个数组。

先预测：second[0] = 99; 之后，first[0] 是 10 还是 99？

$ cd ~/java-practice/lesson06
$ if [ -e ArrayAliasDemo.java ]; then mv ArrayAliasDemo.java "ArrayAliasDemo.java.bak.$(date +%s)"; fi
$ nano ArrayAliasDemo.java

public class ArrayAliasDemo {
    public static void main(String[] args) {
        int[] first = {10, 20, 30};
        int[] second = first;
        System.out.println("修改前 first[0] = " + first[0]);
        second[0] = 99;
        System.out.println("通过 second 改完后 first[0] = " + first[0]);
        System.out.println("second[0] = " + second[0]);
        System.out.println("first 的长度：" + first.length);
        System.out.println("second 的长度：" + second.length);
    }
}

$ javac -encoding UTF-8 ArrayAliasDemo.java
$ java ArrayAliasDemo

修改前 first[0] = 10
通过 second 改完后 first[0] = 99
second[0] = 99
first 的长度：3
second 的长度：3

可以把它想成两个名字挂在同一排格子上：

first  ─┐
        ├──> [10, 20, 30]
second ─┘

改的是格子里的值，不是名字。两个变量看到的长度也都是 3，因为它们指向同一个数组。**数组变量之间用 = 赋值，复制的是“指向同一排格子”的引用，不是元素副本。** 这一点现在先浅讲；第四单元讲对象时还会遇到引用。

如果想让第二个数组独立，需要重新创建，例如 second = new int[]{10, 20, 30};（second 已经声明过时，不能重复写 int[]）。这会开一排新格子，改 second 不会影响 first。本阶段不展开复制数组的 API。

把前面的东西合起来：用 new int[5] 开 5 个格子，用 for 循环读 5 次 Scanner.nextInt()，把每次输入写进 scores[i]；再用第二个 for 遍历输出。这是本节的目标：**一个 int[] 保存 5 个成绩，完整遍历输出。**

Scanner 还是第一单元那个；文件第一行保留 import java.util.Scanner;，否则 javac 会报 cannot find symbol。

先预测：如果输入依次是 88、92、75、60、95，第二个循环会打印哪 5 行？提示语会打印几次？

$ cd ~/java-practice/lesson06
$ if [ -e ScoreInputDemo.java ]; then mv ScoreInputDemo.java "ScoreInputDemo.java.bak.$(date +%s)"; fi
$ nano ScoreInputDemo.java

import java.util.Scanner;

public class ScoreInputDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] scores = new int[5];
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第 " + (i + 1) + " 个成绩：");
            scores[i] = sc.nextInt();
        }
        System.out.println("你输入的成绩是：");
        for (int i = 0; i < scores.length; i++) {
            System.out.println("第 " + (i + 1) + " 个：" + scores[i]);
        }
    }
}

编译后，用 printf 把 5 行输入送进程序；\n 表示换行，printf 是 shell 命令，不是 Java 语法：

$ javac -encoding UTF-8 ScoreInputDemo.java
$ printf '88\n92\n75\n60\n95\n' | java ScoreInputDemo

交互输入（示例，只读）：

88
92
75
60
95

请输入第 1 个成绩：
请输入第 2 个成绩：
请输入第 3 个成绩：
请输入第 4 个成绩：
请输入第 5 个成绩：
你输入的成绩是：
第 1 个：88
第 2 个：92
第 3 个：75
第 4 个：60
第 5 个：95

第一个循环的 i 从 0 到 4，scores[i] 依次接住 5 个输入；第二个循环再从 0 到 4 读出来。(i + 1) 的括号不能省："第 " + i + 1 会先拼成“第 0”再拼 1，变成“第 01”，不是“第 1”。字符串 + 的细节第一单元讲过，这里再用一次。

如果只输入 4 个数，程序会等第 5 个；用 printf 固定输入时，第 5 次 nextInt() 没有数据可读，会抛 NoSuchElementException。这不是数组越界，是输入不够。看到“等住”或 NoSuchElementException，先数 input 块是不是 5 行。