Java 数组基础知识详解 – wiki基地

---

Java 数组基础知识详解：数据集合的基石

在 Java 编程中，我们经常需要处理一组相关的数据。想象一下，如果你要存储一个班级的学生分数、一周的天气预报或者一系列的股票价格，如果为每个数据都创建一个单独的变量，那将是多么繁琐和低效的事情。幸运的是，Java 提供了数组（Array）这种强大的数据结构，它允许我们在一个统一的名称下存储多个相同类型的数据。数组是 Java 语言中最基本、最重要的数据结构之一，理解和掌握数组是学习 Java 的必经之路。

本文将深入浅出地详细介绍 Java 数组的基础知识，包括数组的定义、声明、创建、初始化、访问、遍历、多维数组以及数组在内存中的表示等方面，并辅以丰富的代码示例，帮助读者全面掌握 Java 数组的使用。

第一部分：什么是数组？为什么使用数组？

1.1 数组的定义

从概念上讲，数组是一个存储固定大小的同类型元素的线性集合。这里的关键点有两个：

• 同类型元素：数组中的所有元素必须是同一个数据类型，可以是基本数据类型（如 int, double, boolean 等）或引用数据类型（如 String, 对象等）。
• 固定大小：数组一旦创建，其大小（即能容纳的元素个数）就确定了，不能改变。
• 线性集合：数组中的元素是按照顺序排列的，可以通过索引（或下标）来访问数组中的特定元素。

在 Java 中，数组本身是一个对象。当你创建一个数组时，实际上是在内存（堆）中分配了一块连续的内存空间来存储这些元素。

1.2 为什么使用数组？

使用数组的主要优势在于它能够高效地组织和管理大量同类型的数据。以下是一些使用数组的常见场景和好处：

• 简化变量管理：无需为每个数据单独声明变量，一个数组名即可代表一组数据。
• 方便批量操作：可以利用循环结构轻松地对数组中的所有元素或部分元素进行相同的操作（如计算总和、查找最大值等）。
• 高效的数据访问：通过索引可以直接访问数组中的任意元素，时间复杂度为 O(1)，非常快速。
• 存储序列数据：数组天然适合存储具有先后顺序的数据，如时间序列数据、列表等。
• 作为方法参数和返回值：可以将整个数组作为方法的参数传递，也可以从方法中返回一个数组，方便数据在不同模块间的传递。

第二部分：Java 数组的基本操作

掌握数组的基本操作是使用数组的前提。这包括声明、创建、初始化、访问和遍历。

2.1 数组的声明 (Declaration)

在使用数组之前，我们需要先声明一个数组变量。声明告诉编译器变量的名称以及它将引用的数组的类型。声明数组有两种常用的语法：

1. 推荐方式：将方括号放在类型名之后。

   java
dataType[] arrayName;

   例如：
   java
int[] numbers; // 声明一个整型数组变量
String[] names; // 声明一个字符串数组变量
double[] temperatures; // 声明一个双精度浮点型数组变量
   这种方式将 dataType[] 视为一个整体，更好地体现了变量 arrayName 将引用一个 dataType 类型的数组。

2. C/C++ 风格：将方括号放在变量名之后。

   java
dataType arrayName[];

   例如：
   java
int numbers[]; // 声明一个整型数组变量
String names[]; // 声明一个字符串数组变量
   这种方式也是合法的，但通常不推荐在 Java 中使用，因为它可能会让人误以为 dataType 是变量类型，而 [] 是变量名的一部分，而不是类型的一部分。

重要提示：数组声明只告诉编译器这个变量将引用一个数组，但并没有实际创建数组对象，也没有分配内存空间。此时，数组变量的值是 null。

2.2 数组的创建 (Creation)

声明数组后，我们需要实际创建数组对象，也就是在内存中分配空间。这通过 new 关键字来完成。创建数组时，必须指定数组的大小（元素的个数）。

java
arrayName = new dataType[size];

其中，size 是一个非负整数表达式，表示数组将容纳的元素个数。

例如：
“`java
int[] numbers;
numbers = new int[10]; // 创建一个包含10个整型元素的数组

String[] names;
names = new String[5]; // 创建一个包含5个字符串元素的数组
“`

当使用 new 创建数组时，JVM 会为数组的每个元素分配默认值：

• 数值类型 (byte, short, int, long, float, double) 的默认值是 0 或 0.0。
• 布尔类型 (boolean) 的默认值是 false。
• 字符类型 (char) 的默认值是 '\u0000' (空字符)。
• 引用类型 (对象，包括 String 和其他数组) 的默认值是 null。

2.3 声明和创建的结合

通常，我们会将数组的声明和创建结合在一条语句中：

java
dataType[] arrayName = new dataType[size];

例如：
java
int[] numbers = new int[10];
String[] names = new String[5];
double[] temperatures = new double[30];
这是最常见的创建数组的方式。

2.4 数组的初始化 (Initialization)

创建数组后，其元素会被自动赋予默认值。但我们通常需要为数组元素赋予特定的初始值。有几种方式可以初始化数组：

1. 使用默认值：如上所述，使用 new 创建数组后，元素自动初始化为默认值。

2. 逐个赋值：通过索引访问每个元素并赋予指定的值。

   java
int[] scores = new int[3];
scores[0] = 90; // 数组的第一个元素，索引是0
scores[1] = 85; // 数组的第二个元素，索引是1
scores[2] = 92; // 数组的第三个元素，索引是2
   注意：数组的索引总是从 0 开始，到 size - 1 结束。如果尝试访问超出这个范围的索引（例如 scores[3]），会抛出 ArrayIndexOutOfBoundsException 运行时异常。

3. 声明、创建并初始化：在使用 new 创建数组时，也可以使用初始化列表 {...} 直接为数组元素赋值。这种方式适用于在创建时就知道所有元素值的情况。

   java
dataType[] arrayName = {element1, element2, element3, ...};

   例如：
   java
int[] scores = {90, 85, 92}; // 创建一个包含3个元素的整型数组，并赋值
String[] weekdays = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
double[] prices = {19.99, 24.50, 12.00};
   使用初始化列表时，不能同时指定数组大小。编译器会根据初始化列表中元素的个数自动确定数组的大小。例如，int[] scores = new int[3] {90, 85, 92}; 是错误的语法。

4. 匿名数组初始化：在某些情况下，特别是作为方法参数传递时，可以使用匿名数组来初始化。

   java
new dataType[]{element1, element2, ...}

   例如：
   java
// 假设有一个方法 processArray(int[] arr)
processArray(new int[]{10, 20, 30}); // 直接传递一个匿名数组
   这种方式在声明时不常用，但在方法调用或初始化其他对象时很方便。

2.5 访问数组元素 (Accessing Elements)

通过数组名和索引可以访问数组中的单个元素。索引是元素在数组中的位置，从 0 开始。

java
arrayName[index]

例如，对于上面创建的 scores 数组：
“`java
int firstScore = scores[0]; // 获取第一个元素的值 (90)
int secondScore = scores[1]; // 获取第二个元素的值 (85)

scores[2] = 95; // 修改第三个元素的值为 95

System.out.println(“第一个分数: ” + scores[0]); // 输出 90
System.out.println(“第三个分数: ” + scores[2]); // 输出 95
“`

索引越界异常 (ArrayIndexOutOfBoundsException)

正如前面提到的，尝试访问一个超出有效索引范围（0 到 arrayName.length - 1）的数组元素会导致 ArrayIndexOutOfBoundsException。这是 Java 中一个常见的运行时错误。

java
int[] arr = new int[5];
// 有效索引是 0, 1, 2, 3, 4
System.out.println(arr[5]); // 错误！尝试访问索引 5，会抛出 ArrayIndexOutOfBoundsException
System.out.println(arr[-1]); // 错误！尝试访问索引 -1，也会抛出 ArrayIndexOutOfBoundsException
在编写涉及数组索引的代码时，务必小心，确保索引值始终在合法范围内。

2.6 获取数组长度 (.length)

每个数组对象都有一个内置的公共成员 length，它是一个 final 字段，表示数组中元素的个数。length 是一个常量，不能修改。

“`java
int[] numbers = new int[10];
int size = numbers.length; // size 的值为 10

String[] weekdays = {“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”, “Sunday”};
int dayCount = weekdays.length; // dayCount 的值为 7

System.out.println(“numbers 数组的长度是: ” + size);
System.out.println(“weekdays 数组的长度是: ” + dayCount);
``length` 属性在遍历数组时非常有用，可以用来控制循环的次数。

2.7 遍历数组 (Iterating Through Arrays)

遍历数组是指按顺序访问数组中的每一个元素。Java 提供了几种遍历数组的方式。

1. 标准 for 循环：这是最常见的遍历方式，通过索引来访问元素。

   java
int[] scores = {90, 85, 92, 78, 95};
for (int i = 0; i < scores.length; i++) {
System.out.println("元素在索引 " + i + " 的位置: " + scores[i]);
}
   这种方式可以访问元素的索引和值，适合需要知道元素位置或需要修改元素值的情况。

2. 增强 for 循环 (For-Each Loop)：这是 Java 5 引入的一种更简洁的遍历方式，特别适用于只需要访问数组元素值而不需要知道其索引的情况。

   “`java
   int[] scores = {90, 85, 92, 78, 95};
   for (int score : scores) {
   System.out.println(“元素值: ” + score);
   }

   String[] names = {“Alice”, “Bob”, “Charlie”};
   for (String name : names) {
   System.out.println(“名字: ” + name);
   }
   ``
增强for循环的语法是for (elementType elementVariable : collectionOrArray)。它会依次将数组（或集合）中的每个元素赋值给elementVariable`，然后执行循环体。

   注意：增强 for 循环不能用于修改数组元素的值（因为它操作的是元素的副本，对于基本类型来说），也不能获取元素的索引。如果需要在遍历过程中修改元素或需要索引，必须使用标准 for 循环。

3. 使用 while 或 do-while 循环：虽然不如 for 循环常见，但也可以使用 while 或 do-while 循环结合索引来遍历数组。

   java
int[] data = {10, 20, 30, 40};
int i = 0;
while (i < data.length) {
System.out.println("元素: " + data[i]);
i++;
}

第三部分：数组作为对象

在 Java 中，数组是一个对象，与基本数据类型变量不同。理解这一点对于理解数组在内存中的工作方式以及数组作为方法参数和返回值时的行为至关重要。

• 堆内存分配：当你使用 new 关键字创建数组时，数组对象及其包含的元素（如果是基本类型）或引用（如果是引用类型）都被存储在堆（Heap）内存中。
• 栈内存引用：声明的数组变量（如 int[] numbers;）实际上是一个引用变量，存储在栈（Stack）内存中。这个引用变量存储的是数组对象在堆内存中的地址。
• 赋值操作：当你将一个数组变量赋值给另一个数组变量时（如 int[] arr1 = arr2;），实际上是将 arr2 引用的地址赋值给了 arr1。这意味着 arr1 和 arr2 现在都指向堆内存中的同一个数组对象。改变通过 arr1 访问的元素，通过 arr2 访问时也会看到变化。

“`java
int[] original = {1, 2, 3};
int[] copy = original; // copy 现在引用同一个数组对象

copy[0] = 100; // 通过 copy 修改元素

System.out.println(original[0]); // 输出 100，因为 original 和 copy 指向同一个数组
“`

如果想创建一个独立的数组副本，需要手动创建一个新数组并将原数组的元素复制过去，或者使用 Arrays.copyOf() 等方法。

第四部分：多维数组 (Multidimensional Arrays)

Java 支持多维数组，最常见的是二维数组。多维数组可以被理解为“数组的数组”。例如，二维数组可以看作是一个表格，有行和列。

4.1 二维数组

二维数组的声明、创建和初始化：

1. 声明：

   java
dataType[][] arrayName;
// 或 dataType arrayName[][];
// 或 dataType[] arrayName[]; // 不常用

   例如：
   java
int[][] matrix;
String[][] board;

2. 创建：创建二维数组时，需要指定“行数”和“列数”。

   java
arrayName = new dataType[rowCount][columnCount];

   例如：
   java
int[][] matrix = new int[3][4]; // 创建一个 3 行 4 列的整型二维数组
// 相当于创建了一个包含 3 个一维数组的数组，每个一维数组有 4 个 int 元素

3. 初始化：

   • 默认值：使用 new 创建后，所有元素按其类型赋默认值。

   • 逐个赋值：通过两个索引（行索引和列索引）访问元素。

     java
int[][] matrix = new int[2][3];
matrix[0][0] = 1; // 第 0 行，第 0 列
matrix[0][1] = 2; // 第 0 行，第 1 列
matrix[1][2] = 6; // 第 1 行，第 2 列
     同样，索引范围是 0 到 rowCount - 1 和 0 到 columnCount - 1。

   • 使用初始化列表：可以使用嵌套的初始化列表来创建并初始化二维数组。

     java
dataType[][] arrayName = {
{element1_1, element1_2, ...},
{element2_1, element2_2, ...},
...
};

     例如：
     java
int[][] matrix = {
{1, 2, 3}, // 第 0 行
{4, 5, 6, 7}, // 第 1 行
{8, 9} // 第 2 行
};
     重要：使用初始化列表创建二维数组时，每一行的元素个数可以不同！这引出了不规则数组（Jagged Array）的概念。

4.2 不规则数组 (Jagged Arrays)

Java 的多维数组实际上是“数组的数组”，这意味着每一行的“内层数组”是独立的对象。因此，这些内层数组可以有不同的长度。这种行长不等的二维数组被称为不规则数组或锯齿数组。

创建不规则数组时，只需在创建外层数组时指定行数，然后单独为每一行创建内层数组并指定其长度：

“`java
int[][] jaggedArray = new int[3][]; // 只指定行数，不指定列数

jaggedArray[0] = new int[5]; // 第 0 行有 5 个元素
jaggedArray[1] = new int[2]; // 第 1 行有 2 个元素
jaggedArray[2] = new int[7]; // 第 2 行有 7 个元素

// 此时可以通过索引访问和赋值
jaggedArray[0][0] = 10;
jaggedArray[1][1] = 20;
jaggedArray[2][6] = 30;
“`
使用初始化列表创建的二维数组如果每行的元素个数不同，本质上就是一个不规则数组。

4.3 多维数组的访问和遍历

访问多维数组的元素需要使用对应维度的索引：

java
int element = matrix[rowIndex][columnIndex];
matrix[rowIndex][columnIndex] = newValue;

遍历多维数组通常使用嵌套循环：

“`java
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

// 遍历二维数组
for (int i = 0; i < matrix.length; i++) { // 外层循环控制行，matrix.length 是行数
for (int j = 0; j < matrix[i].length; j++) { // 内层循环控制列，matrix[i].length 是当前行的列数
System.out.print(matrix[i][j] + ” “);
}
System.out.println(); // 打印完一行后换行
}

// 使用增强 for 循环遍历二维数组
for (int[] row : matrix) { // 每次迭代得到一行 (一个一维数组)
for (int element : row) { // 迭代当前行中的每个元素
System.out.print(element + ” “);
}
System.out.println();
}
``
对于不规则数组，内层循环的结束条件必须使用matrix[i].length` 来获取当前行的实际长度，而不是一个固定的列数。

4.4 三维或更高维数组

Java 也支持三维、四维甚至更高维的数组，它们的原理类似，只是需要更多层的方括号和更多层的嵌套循环来访问和遍历。例如，三维数组可以看作是“二维数组的数组”，可以用来表示立方体或三维空间中的点集。

java
int[][][] threeDArray = new int[2][3][4]; // 一个 2x3x4 的三维数组
threeDArray[0][1][2] = 100; // 访问一个元素
在高维数组中，访问和管理变得更加复杂，通常在需要表示复杂空间结构或多层数据时才会使用。

第五部分：数组与方法

数组可以作为方法的参数传递，也可以作为方法的返回值。

5.1 数组作为方法参数

当数组作为方法的参数传递时，实际上传递的是数组的引用（地址）。这意味着在方法内部对数组元素的修改，会影响到方法外部的原始数组。这是因为数组是对象，Java 中对象类型的参数传递是传值调用，但传递的值是对象的引用，所以方法内部和外部引用的是同一个对象。

“`java
public class ArrayMethodExample {

// 方法接收一个整型数组作为参数
public static void printArray(int[] arr) {
    System.out.print("数组元素: ");
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + (i < arr.length - 1 ? ", " : ""));
    }
    System.out.println();
}

// 方法修改数组的第一个元素
public static void modifyFirstElement(int[] arr, int newValue) {
    if (arr != null && arr.length > 0) {
        arr[0] = newValue; // 修改数组元素
        System.out.println("在方法内修改了第一个元素为: " + arr[0]);
    }
}

public static void main(String[] args) {
    int[] myNumbers = {10, 20, 30, 40};

    System.out.print("调用方法前: ");
    printArray(myNumbers); // 传递数组引用

    modifyFirstElement(myNumbers, 99); // 传递数组引用和新值

    System.out.print("调用方法后: ");
    printArray(myNumbers); // 查看数组是否被修改 (会被修改)
}

}
``
运行上述代码会发现，modifyFirstElement方法确实改变了myNumbers` 数组的第一个元素。

5.2 数组作为方法返回值

方法也可以返回一个数组。这在需要生成一个数组作为结果的场景中非常有用。

“`java
public class ArrayReturnExample {

// 方法返回一个包含指定范围内整数的数组
public static int[] createRangeArray(int start, int end) {
    if (start > end) {
        return new int[0]; // 或者返回 null，取决于需求
    }
    int size = end - start + 1;
    int[] result = new int[size];
    for (int i = 0; i < size; i++) {
        result[i] = start + i;
    }
    return result; // 返回新创建的数组的引用
}

public static void main(String[] args) {
    int[] numbers = createRangeArray(5, 10); // 接收方法返回的数组引用

    System.out.print("方法返回的数组: ");
    for (int i = 0; i < numbers.length; i++) {
        System.out.print(numbers[i] + (i < numbers.length - 1 ? ", " : ""));
    }
    System.out.println();
}

}
``createRangeArray方法创建了一个新的数组对象，并返回其引用。在main方法中，numbers` 变量接收了这个引用，从而可以访问和使用这个新创建的数组。

第六部分：Arrays 工具类

Java 提供了一个 java.util.Arrays 工具类，它包含了许多用于操作数组的静态方法，非常方便和高效。常用的方法包括：

• Arrays.sort(array)：对数组进行排序。
• Arrays.binarySearch(array, value)：在已排序的数组中查找指定值的索引（使用二分查找）。
• Arrays.copyOf(originalArray, newLength)：复制数组，可以指定新长度，用于扩展或截断数组。
• Arrays.copyOfRange(originalArray, from, to)：复制数组的指定范围。
• Arrays.equals(array1, array2)：比较两个数组是否相等（元素类型、个数、对应位置的值都相同）。
• Arrays.fill(array, value)：将数组的所有元素设置为指定值。
• Arrays.toString(array)：将数组转换为字符串表示（方便打印输出）。

“`java
import java.util.Arrays;

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

    System.out.println("原数组: " + Arrays.toString(numbers)); // 使用 toString 方便打印

    Arrays.sort(numbers); // 排序
    System.out.println("排序后: " + Arrays.toString(numbers));

    int index = Arrays.binarySearch(numbers, 8); // 二分查找
    System.out.println("8 在排序后数组中的索引: " + index); // 输出索引 3

    int[] copiedArray = Arrays.copyOf(numbers, numbers.length + 2); // 复制并扩展
    System.out.println("复制并扩展后: " + Arrays.toString(copiedArray)); // 后面两个元素是默认值 0

    int[] rangeCopy = Arrays.copyOfRange(numbers, 1, 4); // 复制索引 1 到 3 (不包含 4)
    System.out.println("复制索引 1 到 3: " + Arrays.toString(rangeCopy)); // 输出 [2, 5, 8]

    int[] filledArray = new int[3];
    Arrays.fill(filledArray, 10); // 填充
    System.out.println("填充后: " + Arrays.toString(filledArray)); // 输出 [10, 10, 10]
}

}
``Arrays` 类提供了很多强大的数组操作功能，是处理数组时不可或缺的工具。

第七部分：数组的限制与替代方案

数组最大的限制在于它的固定大小。一旦创建，数组的长度就不能改变。如果在程序运行过程中需要存储数量不确定的数据，或者数据量会动态变化，那么数组就显得不够灵活。

为了克服数组的固定大小限制，Java 提供了各种集合类（Collections），特别是 java.util.ArrayList。ArrayList 是一个基于数组实现的列表，但它的大小是动态可变的，可以根据需要自动扩容。

“`java
import java.util.ArrayList;

public class ArrayListExample {
public static void main(String[] args) {
ArrayList names = new ArrayList<>(); // 创建一个动态大小的字符串列表

    names.add("Alice"); // 添加元素
    names.add("Bob");
    names.add("Charlie");

    System.out.println("列表大小: " + names.size()); // 获取元素个数

    names.add("David"); // 继续添加元素，列表自动扩容

    System.out.println("添加后列表大小: " + names.size()); // 列表大小变化

    // 访问元素
    System.out.println("第一个元素: " + names.get(0));

    // 遍历列表
    for (String name : names) {
        System.out.println(name);
    }
}

}
``
对于需要动态大小的数据集合，通常更推荐使用ArrayList` 或其他集合类。然而，对于大小确定且需要频繁通过索引访问的场景，数组仍然是最高效的选择。

第八部分：总结与实践建议

数组是 Java 中存储和管理同类型数据的基础数据结构。它提供了一种简单而高效的方式来处理固定大小的数据集。

关键概念回顾：

• 数组存储同类型、固定大小的元素。
• 数组是对象，存储在堆内存中，变量存储引用。
• 索引从 0 开始，到 length - 1 结束。
• 索引越界会导致 ArrayIndexOutOfBoundsException。
• 多维数组是数组的数组，支持不规则数组。
• Arrays 工具类提供了丰富的数组操作方法。
• 数组大小固定是其主要限制，动态大小需求应考虑集合类如 ArrayList。

掌握数组的使用是 Java 编程的基础。在实际开发中，你会频繁地遇到需要使用数组的场景。建议通过大量的编程练习来巩固对数组的理解和运用。尝试编写程序来完成以下任务：

• 输入一组数字并存储到数组中，然后计算它们的总和和平均值。
• 在一个数组中查找最大值或最小值。
• 实现数组元素的逆序排列。
• 使用冒泡排序或其他排序算法对数组进行排序。
• 在二维数组中查找特定元素或计算矩阵的转置。

通过实践，你将更加熟练地运用 Java 数组这一强大的工具，为学习更复杂的数据结构和算法打下坚实的基础。

---

这篇文章详细介绍了 Java 数组的基础知识，从定义、创建到高级用法如多维数组和 Arrays 工具类。希望通过这些详细的解释和代码示例，能够帮助你全面理解和掌握 Java 数组的使用。数组是构建更复杂程序和数据结构的基石，祝你在 Java 学习之路上顺利前行！