Java 基础--数组(Array)：存储数据的“排排坐”

作者：IvanCodes

发布时间：2025年5月1日🤓

专栏：Java教程

---

大家好！👋 咱们在编程时，经常需要处理一批相同类型的数据，比如班级里所有同学的成绩 💯、一周每天的最高气温 🌡️、或者购物车里的商品列表 🛒。如果为每个数据都声明一个单独的变量（score1, score2, score3…），那代码不得写“疯”了？🤯

这时候，就轮到 Java 中的一个基础且重要的数据结构登场了——数组 (Array)！你可以把它 想象成一排带编号的储物柜 或者一个鸡蛋托 🥚，专门用来整齐地存放 多个相同类型 的数据。今天，我们就来把数组这个“老朋友”彻底搞明白！

一、 数组到底是个啥？🤔

简单来说，数组就是一个固定大小的容器 📦，里面存放的元素必须是相同的数据类型。

几个关键特性要记住：

1. 类型统一：一个 int 数组里只能放 int，一个 String 数组里只能放 String。不能混装！🚫
2. 长度固定 : 数组一旦创建，它的长度（能装多少个元素）就不能再改变了！这是数组最核心的限制之一 ⚠️。
3. 连续存储 (通常): 在内存中，数组的元素通常是连续存放的，这使得通过索引访问元素非常快 ⚡️。
4. 索引访问 : 每个元素都有一个唯一的索引（编号），从 0 开始！通过索引可以快速定位和访问元素。

二、 创建和使用数组 ✍️

怎么在代码里用数组呢？主要分两步：声明和初始化。

2.1 声明数组引用

告诉编译器：“我要一个能指向某种类型数组的变量”。

// 推荐的声明方式
int[] scores;
String[] names;
double[] prices;

// C/C++ 风格的声明方式 (也能用，但不推荐)
// int scores[];
// String names[];

注意：这只是声明了一个引用变量，它现在还是 null，并没有指向任何实际的数组内存空间。

2.2 初始化数组（分配空间/赋值）

初始化才是真正创建数组对象、分配内存空间的时候。有两种主要方式：

方式一：使用 new 指定长度

这是最常用的方式，你知道需要多大的数组，但还不确定里面的具体值。

// 创建一个能存放 5 个 int 的数组
scores = new int[5]; // 分配了 5 个 int 的空间

// 创建一个能存放 10 个 String 的数组
names = new String[10]; // 分配了 10 个 String 引用的空间

// 声明和初始化可以合并
double[] salaries = new double[50];

重点📌: 使用 new 创建数组后，里面的元素会被自动赋予默认值：

• 数值类型 (int, double etc.): 0 或 0.0
• boolean: false
• char: \u0000 (空字符)
• 引用类型 (String, Object etc.): null

方式二：静态初始化 (直接提供元素值)

如果你在创建数组时就已经知道里面要放哪些元素了，可以用这种更简洁的方式。编译器会根据你提供的值自动确定数组的长度。

// 直接提供初始值，长度由编译器确定 (这里是 4)
int[] initialScores = {90, 85, 92, 78};

// 声明和静态初始化合并
String[] weekdays = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"};

// 不能分开写！下面这样是错误的 ❌
// int[] numbers;
// numbers = {1, 2, 3}; // 编译错误
// 必须这样写：
int[] numbers;
numbers = new int[]{1, 2, 3}; // 或者声明时就初始化

2.3 访问数组元素：靠索引 [] 👉

数组的核心操作就是通过索引来存取元素。记住：索引从 0 开始！ 非常非常重要！ 🚨

public class ArrayAccess {
    public static void main(String[] args) {
        String[] fruits = {"Apple <🍎>", "Banana <🍌>", "Orange <🍊>"}; // 长度为 3

        // 访问元素 (索引 0, 1, 2)
        System.out.println("First fruit: " + fruits[0]); // Apple <🍎> (索引 0)
        System.out.println("Second fruit: " + fruits[1]); // Banana <🍌> (索引 1)
        System.out.println("Third fruit: " + fruits[2]); // Orange <🍊> (索引 2)

        // 修改元素
        fruits[1] = "Grape <🍇>"; // 把第 2 个元素 (索引 1) 改成 Grape
        System.out.println("Second fruit now: " + fruits[1]); // Grape <🍇>

        // 尝试访问不存在的索引？后果很严重！
        // System.out.println(fruits[3]); // 运行时错误💥: ArrayIndexOutOfBoundsException
    }
}

2.4 获取数组长度：.length 属性 📏

想知道数组能装多少东西？用 .length 属性（注意：是属性，不是方法，后面没有括号 ()，这点和 String 的 length() 方法不同，容易混淆！）。

int[] data = new int[10];
System.out.println("Length of data array: " + data.length); // Output: 10

String[] colors = {"Red", "Green", "Blue"};
System.out.println("Number of colors: " + colors.length); // Output: 3

.length 在循环遍历数组时特别有用。

三、 遍历数组：挨个“点名” 🚶‍♀️🚶‍♂️

遍历数组就是按顺序访问数组中的每一个元素，通常用循环来实现。

3.1 使用传统 for 循环

最灵活的方式，因为你可以拿到当前的索引 i。

public class ForLoopArray {
    public static void main(String[] args) {
        double[] readings = {12.5, 13.1, 11.8, 12.9};
        System.out.println("Sensor Readings:");
        // 循环条件通常是 i < array.length
        for (int i = 0; i < readings.length; i++) {
            System.out.println("Reading at index " + i + ": " + readings[i]);
        }
    }
}

3.2 使用增强型 for 循环 (for-each)

如果不需要关心索引，只是想依次处理每个元素，这种方式更简洁、易读。

import java.util.ArrayList; // 只是为了演示集合遍历
import java.util.List;

public class ForEachArray {
    public static void main(String[] args) {
        char[] vowels = {'a', 'e', 'i', 'o', 'u'};
        System.out.print("Vowels: ");
        // 依次取出 vowels 数组中的每个 char 赋给变量 vowel
        for (char vowel : vowels) {
            System.out.print(vowel + " ");
        }
        System.out.println(); // 输出: a e i o u

        // 同样适用于集合 (比如 ArrayList)
        // List<String> names = new ArrayList<>(); ...
        // for (String name : names) { ... }
    }
}

如何选择？ 如果需要索引（比如要根据索引修改元素，或者需要知道当前是第几个元素），用传统 for。如果只是读取每个元素的值，增强型 for 通常更好。

四、 数组的“常见烦恼” 😩💥

使用数组时，有几个经典错误你很可能会遇到：

1. ArrayIndexOutOfBoundsException <💥>: 这是最常见的数组错误！当你试图访问一个不存在的索引时（比如索引 < 0，或者索引 >= array.length），就会抛出这个运行时异常。写循环时要特别小心边界条件！
2. NullPointerException : 如果你的数组引用变量本身是 null（即它没有指向任何数组对象），而你试图访问它的 .length 属性或者通过索引访问元素（如 nullArray[0]），就会得到这个运行时异常。使用数组前，确保它已经被正确初始化了！
3. 长度固定不变 <🔒>: 前面强调过，数组长度一旦确定就不能改。如果你的程序需要一个可以动态增删元素的容器，那么 Java 集合框架中的 ArrayList 等类通常是更好的选择。

五、 超出基础：多维数组与 Arrays 工具类 ▦🛠️

5.1 多维数组

你可以创建“数组的数组”，最常见的是二维数组，可以把它想象成一个表格或矩阵 ▦。

// 创建一个 3行 4列 的 int 二维数组
int[][] matrix = new int[3][4];

// 静态初始化
String[][] board = {
    {"X", "O", "X"},
    {"O", "X", "O"},
    {"X", "O", "X"}
};

// 访问元素需要两个索引
matrix[0][1] = 5; // 设置第 1 行第 2 列 (索引都是从 0 开始)
System.out.println("Board[1][1]: " + board[1][1]); // Output: X

遍历二维数组通常需要嵌套循环。

5.2 java.util.Arrays 工具类 <🛠️>

Java 提供了一个非常有用的 Arrays 类（在 java.util 包下），里面包含了很多操作数组的static方法，能省不少事：

• Arrays.toString(array): 把数组转换成易于阅读的字符串形式，方便打印调试，强烈推荐！👍
• Arrays.sort(array): 对数组进行排序（原地排序）。
• Arrays.fill(array, value): 用指定值填充整个数组。
• Arrays.copyOf(originalArray, newLength): 复制原数组的一部分或全部到一个新的数组（可以用来变相“扩展”数组）。
• Arrays.equals(array1, array2): 比较两个数组的内容是否相等（注意，不是用 == 比地址）。

import java.util.Arrays; // <--- 别忘了导入！

public class ArraysUtilDemo {
    public static void main(String[] args) {
        int[] nums = {5, 2, 8, 1, 9};

        // 好看的打印方式
        System.out.println("Original array: " + Arrays.toString(nums));

        // 排序
        Arrays.sort(nums);
        System.out.println("Sorted array: " + Arrays.toString(nums));

        // 填充
        int[] filled = new int[5];
        Arrays.fill(filled, -1);
        System.out.println("Filled array: " + Arrays.toString(filled));

        // 复制 (取前 3 个元素)
        int[] copied = Arrays.copyOf(nums, 3); // nums 已经是排序后的 {1, 2, 5, 8, 9}
        System.out.println("Copied first 3: " + Arrays.toString(copied));
    }
}

六、总结 🏁

数组是 Java 中存储固定数量、相同类型元素的基础数据结构。

• 核心特性：类型统一、长度固定、索引访问 (从 0 开始)。
• 创建方式：new Type[size] 或静态初始化 {...}。
• 访问与长度：使用 array[index] 访问，.length 获取长度。
• 遍历：常用 for 或增强 for 循环。
• 常见陷阱 🚨：ArrayIndexOutOfBoundsException, NullPointerException, 长度固定限制。
• 好帮手 <🛠️>：java.util.Arrays 类提供了很多实用方法。

虽然 ArrayList 等集合类在灵活性上更胜一筹，但数组在性能（尤其是访问速度）和表示固定大小数据集时仍然有其优势，并且是理解集合类的基础。所以，扎实掌握数组非常重要！

---

七、练练手，检验成果！✏️🧠

来，动手写写代码，巩固一下！

⭐ 基础操作 ⭐

1. 声明一个可以存放 10 个 double 类型数据的数组 prices，并将其所有元素初始化为 9.99 (使用循环或 Arrays.fill)。
2. 创建一个 String 数组 colors，包含 “Red”, “Green”, “Blue”, “Yellow”。然后，修改第三个元素 (“Blue”) 为 “Purple”，并打印修改后的数组内容 (使用 Arrays.toString)。

⭐ 循环与计算 ⭐

3. 给定一个 int 数组 scores = {88, 92, 75, 98, 85}，计算并打印数组中所有分数的平均值 (注意结果可能是小数)。
4. 查找数组 int[] data = {5, -2, 9, 15, -8, 1} 中的最大值，并打印出来。

⭐ 概念辨析 ⭐

5. 尝试解释为什么数组的索引是从 0 开始而不是从 1 开始？(提示：可以从内存地址和偏移量角度思考，或说明其历史渊源和编程习惯)
6. 比较数组 (int[]) 和 ArrayList<Integer> 的主要区别，尤其是在大小和类型方面。

---

八、参考答案 ✅💡

⭐ 基础操作答案 ⭐

1.初始化 prices 数组:

import java.util.Arrays;

public class InitPrices {
    public static void main(String[] args) {
        double[] prices = new double[10];

        // 方法一：使用循环
        // for (int i = 0; i < prices.length; i++) {
        //     prices[i] = 9.99;
        // }

        // 方法二：使用 Arrays.fill (更推荐)
        Arrays.fill(prices, 9.99);

        System.out.println("Initialized prices: " + Arrays.toString(prices));
    }
}

2.修改 colors 数组:

import java.util.Arrays;

public class ModifyColors {
    public static void main(String[] args) {
        String[] colors = {"Red", "Green", "Blue", "Yellow"};
        System.out.println("Original colors: " + Arrays.toString(colors));

        // 第三个元素索引是 2
        if (colors.length > 2) { // 做个简单检查防止越界
            colors[2] = "Purple <💜>";
        }

        System.out.println("Modified colors: " + Arrays.toString(colors));
        // 输出: Modified colors: [Red, Green, Purple <💜>, Yellow]
    }
}

⭐ 循环与计算答案 ⭐

3.计算平均分:

import java.util.Arrays;

public class AverageScore {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 98, 85};
        if (scores.length == 0) {
            System.out.println("Array is empty, cannot calculate average.");
            return;
        }

        int sum = 0;
        for (int score : scores) {
            sum += score;
        }

        // 注意：为了得到精确的小数结果，需要将 sum 或 length 转为 double
        double average = (double) sum / scores.length;
        // 或者 double average = sum * 1.0 / scores.length;

        System.out.println("Scores: " + Arrays.toString(scores));
        System.out.println("Average score: " + average); // 输出: Average score: 87.6
    }
}

4.查找最大值:

import java.util.Arrays;

public class FindMaxValue {
    public static void main(String[] args) {
        int[] data = {5, -2, 9, 15, -8, 1};
        if (data.length == 0) {
            System.out.println("Array is empty.");
            return;
        }

        int max = data[0]; // 假设第一个元素是最大值
        for (int i = 1; i < data.length; i++) {
            if (data[i] > max) {
                max = data[i]; // 如果找到更大的，更新 max
            }
        }
        System.out.println("Data: " + Arrays.toString(data));
        System.out.println("Maximum value: " + max); // 输出: Maximum value: 15
    }
}

⭐ 概念辨析答案 ⭐

5.为什么索引从 0 开始？ 这主要是历史原因和底层实现效率的考虑。在 C 语言（Java 的重要祖先）及更早的语言中，数组名通常代表数组第一个元素在内存中的起始地址。访问数组元素 array[i]，实际上是计算 起始地址 + i * 每个元素的大小 来找到第 i+1 个元素的地址。如果索引从 0 开始，那么访问第一个元素 array[0] 就是 起始地址 + 0 * size，即起始地址本身，计算最简单、最高效。如果从 1 开始，访问第一个元素 array[1] 就需要计算 起始地址 + (1-1) * size，多了一步减法。这种从 0 开始的索引（称为 zero-based indexing）已经成为 C 家族语言（包括 C++, Java, C#, JavaScript 等）的编程惯例。

6.int[] vs ArrayList<Integer> 区别:

• 大小:
  • int[]: 大小固定。一旦创建，长度不能改变。
  • ArrayList<Integer>: 大小可变。可以动态添加或删除元素，其内部容量会自动调整（虽然可能涉及性能开销）。
• 类型:
  • int[]: 存储的是基本数据类型 int 的值。
  • ArrayList<Integer>: 存储的是包装类 <font color="purple">Integer</font> 的对象引用。它不能直接存储基本类型 int（但 Java 的自动装箱/拆箱机制使得使用起来很像在存取 int）。
• 功能: ArrayList 提供了更多现成的方法（如 add, remove, contains, size 等），而数组功能相对基础（主要靠索引和 Arrays 工具类）。
• 性能: 对于固定大小且频繁访问的场景，数组通常比 ArrayList 性能稍好（特别是对于基本类型数组，避免了装箱/拆箱开销和对象引用的开销）。

---

希望这篇关于数组的笔记能帮你打下坚实的基础！用熟了它，再去看集合框架就会感觉轻松很多！如果觉得有帮助，别忘了 点赞👍、收藏⭐、关注 哦！感谢！💖