Java 零基础教程

Java 数组元素访问

在 Java 中，访问数组元素是一项最基础的操作。通过它，你可以检索或修改存储在数组特定位置的值。

1. 理解数组索引

在 Java 中，数组中的每个元素都关联着一个唯一的索引（Index）。这些索引是整数值，从 0 开始，直到数组长度减 1。因此，一个长度为 $n$ 的数组，其索引范围是 $0$ 到 $n-1$。这种从零开始的计数系统在许多编程语言中都很常见。

  • 第一个元素： 始终位于索引 0 处。
  • 最后一个元素： 始终位于索引 (数组长度 - 1) 处。
  • 越界访问： 尝试访问有效范围（0 到 n-1）之外的索引会导致 ArrayIndexOutOfBoundsException。这是一个运行时错误，表示你正在尝试访问不属于该数组的内存位置。

示例：

假设有一个名为 numbers 的 int 类型数组，长度为 5。该数组的有效索引为 0, 1, 2, 3 和 4。

索引值
010
120
230
340
450

访问 numbers[0] 会得到值 10；访问 numbers[4] 会得到值 50。而尝试访问 numbers[5] 则会抛出 ArrayIndexOutOfBoundsException，因为索引 5 超出了有效范围。

2. 访问数组元素

要访问数组中的元素，你需要使用数组名称，后跟括在方括号 [] 中的索引。

语法：

数组名[索引]

2.1 读取元素

要获取特定索引处的值，可以使用以下语法：

int value = numbers[2]; // 将索引 2 处的值（即 30）赋值给变量 'value'

2.2 修改元素

要更改特定索引处的值，可以使用赋值运算符 =：

numbers[1] = 25; // 将索引 1 处的值从 20 修改为 25

3. 完整代码示例

下面的代码演示了如何声明、访问、修改数组以及获取数组长度：

public class ArrayAccess {
    public static void main(String[] args) {
        // 声明并初始化一个整数数组
        int[] numbers = {10, 20, 30, 40, 50};

        // 访问元素
        System.out.println("索引 0 处的元素: " + numbers[0]); // 输出: 10
        System.out.println("索引 2 处的元素: " + numbers[2]); // 输出: 30
        System.out.println("索引 4 处的元素: " + numbers[4]); // 输出: 50

        // 修改元素
        numbers[1] = 25;
        System.out.println("修改后索引 1 处的元素: " + numbers[1]); // 输出: 25

        // 获取数组长度的示例
        int arrayLength = numbers.length;
        System.out.println("数组的长度是: " + arrayLength); // 输出: 5

        // 使用 length 属性访问最后一个元素
        System.out.println("数组的最后一个元素: " + numbers[arrayLength - 1]); // 输出: 50
    }
}

4. 遍历数组

在处理数组时，一个常见的任务是遍历（迭代）其所有元素。你可以使用 for 循环或 while 循环来实现。

4.1 使用标准 for 循环

for 循环非常适合遍历数组，因为你通常预先知道元素的数量。

public class ArrayIteration {
    public static void main(String[] args) {
        int[] scores = {85, 90, 78, 92, 88};

        // 使用 for 循环遍历数组
        System.out.println("分数列表：");
        for (int i = 0; i < scores.length; i++) {
            System.out.println("索引 " + i + " 处的分数: " + scores[i]);
        }
    }
}

在此示例中，循环将计数器 i 初始化为 0。只要 i 小于数组长度，循环就会继续。每次迭代都会打印 scores[i] 的值，并将 i 增加 1。

4.2 增强型 for 循环（for-each）

Java 提供了一种更简洁的“增强型 for 循环”，专门用于遍历数组或集合，无需显式处理索引。

public class EnhancedForLoop {
    public static void main(String[] args) {
        String[] names = {"爱丽丝", "鲍勃", "查理", "大卫"};

        // 使用增强型 for 循环遍历数组
        System.out.println("姓名列表：");
        for (String name : names) {
            System.out.println("姓名: " + name);
        }
    }
}

这种写法更易读。在每次循环中，当前的元素会自动赋值给 name 变量。

4.3 循环选择建议

  • 标准 for 循环： 当你需要使用索引（例如打印排名、根据索引修改特定值）或修改数组内容时，请使用它。
  • 增强型 for 循环： 当你只需要读取并处理数组中的每个元素，而不需要索引信息时，请优先使用它，代码会更简洁。

5. 处理 ArrayIndexOutOfBoundsException

为了防止程序因索引错误而崩溃，确保索引处于有效范围（$0$ 到 length - 1）至关重要。

public class ArrayIndexOutOfBounds {
    public static void main(String[] args) {
        int[] values = {100, 200, 300};

        // 这行代码会引发 ArrayIndexOutOfBoundsException，因为索引 3 不存在
        // System.out.println(values[3]);

        // 安全访问：先进行检查
        int index = 3;
        if (index >= 0 && index < values.length) {
            System.out.println("索引 " + index + " 处的值: " + values[index]);
        } else {
            System.out.println("错误：索引 " + index + " 超出范围。");
        }
    }
}

6. 实践示例

6.1 计算数组元素的平均值

public class ArrayAverage {
    public static void main(String[] args) {
        double[] numbers = {5.5, 7.2, 9.1, 6.8, 8.3};
        double sum = 0;
        for (double number : numbers) {
            sum += number;
        }
        double average = sum / numbers.length;
        System.out.println("平均值是: " + average);
    }
}

6.2 寻找数组中的最大值

public class ArrayMax {
    public static void main(String[] args) {
        int[] values = {45, 12, 89, 56, 23};
        int max = values[0]; // 先假设第一个元素是最大的
        for (int i = 1; i < values.length; i++) {
            if (values[i] > max) {
                max = values[i]; // 发现更大的值，更新 max
            }
        }
        System.out.println("最大值是: " + max);
    }
}

6.3 数组反转

public class ArrayReverse {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5};
        int[] reversed = new int[original.length];
        
        for (int i = 0; i < original.length; i++) {
            // 将原数组的值从后往前存入新数组
            reversed[original.length - 1 - i] = original[i];
        }

        System.out.println("原始数组:");
        for (int value : original) {
            System.out.print(value + " ");
        }

        System.out.println("\n反转后的数组:");
        for (int value : reversed) {
            System.out.print(value + " ");
        }
    }
}