【Java篇】内存中的桥梁：Java数组与引用的灵动操作

半截诗

发布于 2025-05-07 14:42:24

14200

代码可运行

文章被收录于专栏：学西学西

运行总次数：0

代码可运行

数组的定义与使用

💬 欢迎讨论：如果你在阅读过程中有任何疑问或想要进一步探讨的内容，欢迎在评论区留言！我们一起学习、一起成长。 👍 点赞、收藏与分享：如果你觉得这篇文章对你有帮助，记得点赞、收藏并分享给更多想了解 Java 编程的朋友！ 🚀 继续学习之旅：今天，我们将深入探讨 Java 中的数组，包括数组概念，如何创建，引用类型等。这些是每个 Java 程序员必备的技能。

一、数组的基本概念

1.1 为什么要使用数组

假设现在要存储5个学生的JavaSE考试成绩，并对其进行输出，按照之前掌握的知识，我们可能会写出如下代码：

public class TestStudent {
    public static void main(String[] args){
        int score1 = 70;
        int score2 = 80;
        int score3 = 85;
        int score4 = 60;
        int score5 = 90;
        
        System.out.println(score1);
        System.out.println(score2);
        System.out.println(score3);
        System.out.println(score4);
        System.out.println(score5);
    }
}

上述代码没有任何问题，但如果需要存储20名同学的成绩，我们就需要创建20个变量。如果有100个学生的成绩，那么我们将不得不创建100个变量。仔细观察这些学生的成绩，发现它们的类型都是相同的。那么，Java中是否存在一种可以存储相同类型多个数据的结构呢？答案就是数组。

1.2 什么是数组

数组：可以看成是相同类型元素的一个集合。在内存中，它们占用的是一段连续的空间。就像现实中的车库，每个车位上停着相同类型的车辆。假设我们有如下代码：

public class TestStudent {
    public static void main(String[] args){
        int score1 = 70;
        int score2 = 80;
        int score3 = 85;
        int score4 = 60;
        int score5 = 90;
        
        System.out.println(score1);
        System.out.println(score2);
        System.out.println(score3);
        System.out.println(score4);
        System.out.println(score5);
    }
}

如果用数组来处理，代码将简洁很多：

public class TestStudent {
    public static void main(String[] args){
        int[] scores = {70, 80, 85, 60, 90};
        
        for(int score : scores){
            System.out.println(score);
        }
    }
}

通过数组，我们可以发现：

数组中存放的元素类型相同。
数组的空间是连续的。
每个元素的编号（索引）从0开始，即数组的下标。

在程序中，如何创建数组呢？

1.3 数组的创建及初始化

1.3.1 数组的创建

数组的创建格式如下：

T[] arrayName;

其中：

T 表示数组中存放元素的类型。
arrayName 表示数组的名称。

例如：

int[] scores;

1.3.2 数组的初始化

数组的初始化主要有两种方式：动态初始化和静态初始化。

动态初始化：在创建数组时，指定数组中元素的个数。

int[] scores = new int[5];  // 创建一个可以容纳5个int类型元素的数组

静态初始化：在创建数组时直接指定元素的值，而不是先指定个数。

int[] scores = {70, 80, 85, 60, 90};  // 直接赋值

在静态初始化时，虽然没有显式指定数组的长度，但编译器会根据数组的元素个数自动推断出长度。例如：

int[] scores = {70, 80, 85, 60, 90};  // 编译时确定长度为5

数组也可以按照如下C语言个数创建，不推荐

/*
该种定义方式不太友好，容易造成数组的类型就是int的误解
[]如果在类型之后，就表示数组类型，因此int[]结合在一块写意思更清晰
*/
int arr[] = {1, 2, 3};

静态和动态初始化也可以分为两步，但是省略格式不可以

int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};
// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3};

如果没有对数组进行初始化，数组中元素有其默认值

如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值，比如：

如果数组中存储元素类型为引用类型，默认值为null

1.4 数组的使用

1.4.1 数组中元素访问

数组的元素通过下标来访问。在内存中，数组的元素是连续存储的，因此通过下标可以快速访问任意位置的元素。下标从0开始，最大下标为 array.length - 1。

例如：

int[] scores = {70, 80, 85, 60, 90};
System.out.println(scores[0]);  // 输出第一个元素
System.out.println(scores[1]);  // 输出第二个元素

【注意事项】

数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素
下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。

int[] array = {1, 2, 3};
System.out.println(array[3]); // 数组中只有3个元素，下标一次为：0 1 2，array[3]下标越界
// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at Test.main(Test.java:4)

抛出了 java.lang.ArrayIndexOutOfBoundsException 异常. 使用数组一定要下标谨防越界.

1.4.2 遍历数组

遍历数组的目的是访问数组中的每个元素，进行操作。传统的遍历方式是通过for循环：

for (int i = 0; i < scores.length; i++) {
    System.out.println(scores[i]);
}

此外，Java还提供了更简洁的for-each遍历方式，适用于不需要使用下标的场景：

for (int score : scores) {
    System.out.println(score);
}

二、数组是引用类型

2.1 初识JVM的内存分布

内存是一段连续的存储空间，主要用来存储程序运行时数据的。比如：

程序运行时代码需要加载到内存
程序运行产生的中间数据要存放在内存
程序中的常量也要保存
有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁

如果对内存中存储的数据不加区分的随意存储，那对内存管理起来将会非常麻烦。比如：

因此JVM也对所使用的内存按照功能的不同进行了划分：

程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址
虚拟机栈 (JVM Stack): 与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。
本地方法栈 (Native Method Stack): 本地方法栈与虚拟机栈的作用类似，只不过保存的内容是Native方法的局部变量。在有些版本的 JVM 实现中(例如HotSpot)，本地方法栈和虚拟机栈是一起的。
堆 (Heap): JVM所管理的最大内存区域。使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。
方法区 (Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。方法编译出的字节码就是保存在这个区域。

现在我们只简单关心堆和 虚拟机栈这两块空间，后序JVM中还会更详细介绍。

2.2 基本类型变量与引用类型变量的区别

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；
而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。

public static void func() {
    int a = 10;
    int b = 20;
    int[] arr = new int[]{1,2,3};
}

在上述代码中，a、b、arr，都是函数内部的变量，因此其空间都在main方法对应的栈帧中分配。

a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。
array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。

从上图可以看到，引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。有点类似C语言中的指针，但是Java中引用要比指针的操作更简单。

2.3 再谈引用变量

public static void func() {
    int[] array1 = new int[3];
    array1[0] = 10;
    array1[1] = 20;
    array1[2] = 30;

    int[] array2 = new int[]{1,2,3,4,5};
    array2[0] = 100;
    array2[1] = 200;

    array1 = array2;
    array1[2] = 300;
    array1[3] = 400;
    array2[4] = 500;
    for (int i = 0; i < array2.length; i++) {
        System.out.println(array2[i]);
    }
}

2.4 认识 null

null 在 Java 中表示 “空引用” , 也就是一个不指向对象的引用.

null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException

注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联.

public static void main(String[] args) {
    int[] arr = null;
    System.out.println(arr[0]);
    
    // 执行结果
    Exception in thread "main" java.lang.NullPointerException
        at Test.main(Test.java:6)
}

三、数组的应用场景

3.1 保存数据

public static void main(String[] args) {
    int[] array = {1, 2, 3};
    
    for(int i = 0; i < array.length; ++i){
        System.out.println(array[i] + " ");
    }
}

3.2 作为函数的参数

参数传基本数据类型

public static void main(String[] args) {
    int num = 0;
    func(num);
    System.out.println("num = " + num);
}

public static void func(int x) {
    x = 10;
    System.out.println("x = " + x);
}

执行结果：

x = 10
num = 0

参数传数组类型(引用数据类型)

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    func(arr);
    System.out.println("arr[0] = " + arr[0]);
}

public static void func(int[] a) {
    a[0] = 10;
    System.out.println("a[0] = " + a[0]);
}

执行结果：

a[0] = 10
arr[0] = 10

3.3 作为函数的返回值

比如：获取斐波那契数列的前N项

public class TestArray {
    public static int[] fib(int n){
        if(n <= 0){
            return null;
        }

        int[] array = new int[n];
        array[0] = array[1] = 1;
        for(int i = 2; i < n; ++i){
            array[i] = array[i-1] + array[i-2];
        }

        return array;
    }

    public static void main(String[] args) {
        int[] array = fib(10);
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

四、数组练习

4.1 数组转字符串

例子：

import java.util.Arrays

int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);

// 执行结果
[1, 2, 3, 4, 5, 6]

使用这个方法后续打印数组就更方便一些. Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法.

4.2 数组拷贝

例子：

import java.util.Arrays;
public static void func(){
    // newArr和arr引用的是同一个数组
    // 因此newArr修改空间中内容之后，arr也可以看到修改的结果
    int[] arr = {1,2,3,4,5,6};
    int[] newArr = arr;
    newArr[0] = 10;
    System.out.println("newArr: " + Arrays.toString(arr));
    
    // 使用Arrays中copyOf方法完成数组的拷贝：
    // copyOf方法在进行数组拷贝时，创建了一个新的数组
    // arr和newArr引用的不是同一个数组
    arr[0] = 1;
    newArr = Arrays.copyOf(arr, arr.length);
    System.out.println("newArr: " + Arrays.toString(newArr));
    
    // 因为arr修改其引用数组中内容时，对newArr没有任何影响
    arr[0] = 10;
    System.out.println("arr: " + Arrays.toString(arr));
    System.out.println("newArr: " + Arrays.toString(newArr));
    
    // 拷贝某个范围.
    int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
    System.out.println("newArr2: " + Arrays.toString(newArr2));
}

下图示意了 Arrays.copyOf(arr, arr.length) 所做的操作。可以看到，新数组与原数组虽然存储的内容相同，但内存空间是不同的。

五、二维数组

5.1 二维数组的概念

二维数组本质上也是一个“一维数组”，只不过每个元素本身又是一个“一维数组”。在 Java 中，int[][] arr; 并不意味着一定是“规则的矩阵”，它可以是“数组的数组”——即每一行的列数不一定相同。

5.2 二维数组的初始化

静态初始化（在声明时直接指定所有元素）：

int[][] arr = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

动态初始化（先分配行数，再为每一行单独分配列数）：

// 分配3行，但列数暂未指定
int[][] arr2 = new int[3][];

// 分别为每一行分配列
arr2[0] = new int[4];
arr2[1] = new int[2];
arr2[2] = new int[5];

// 随后给元素赋值
arr2[0][0] = 1;
arr2[0][1] = 2;
// ...

5.3 遍历二维数组

下面以一个规则的二维数组为例：

public static void main(String[] args) {
    int[][] arr = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    for (int row = 0; row < arr.length; row++) {
        for (int col = 0; col < arr[row].length; col++) {
            System.out.print(arr[row][col] + " ");
        }
        System.out.println(); // 换行
    }
}

执行结果：

1 2 3 4
5 6 7 8
9 10 11 12

如果是非规则的二维数组（即每行列数不同），只要我们在遍历时，针对每行都用 arr[row].length 作为循环上限，就能正确访问每行的元素。

5.4 二维数组在内存中的存储

在 Java 中，二维数组 int[][] 的本质是“数组的数组”：
- arr 本身是一个一维数组，每个元素都是对“一维 int 数组”的引用。
- 每个 arr[row] 又是一个真正存储整数的数组。
因此即使外层数组长度固定，也可以让各行（内层数组）长度不同。

示意图如下（仅供参考）：

arr   ->  [  引用0  |  引用1  |  引用2  ]
            ↓        ↓        ↓
          [1,2,3,4] [5,6,7,8] [9,10,11,12]

上图中，“引用0、引用1、引用2”存储在“外层数组”里；
“内层数组” [1,2,3,4] / [5,6,7,8] / [9,10,11,12] 则存储实际的 int 数据；
这三个内层数组可能在内存中并不一定是紧挨着的，只要通过外层数组的引用就能访问它们。

5.5 示例：二维数组的行交换

为了说明“数组的数组”这一特点，来看一个交换二维数组行的例子：

public static void swapRow(int[][] arr, int r1, int r2) {
    // 如果 r1、r2 下标合法，则直接交换引用
    if (r1 >= 0 && r1 < arr.length && r2 >= 0 && r2 < arr.length) {
        int[] temp = arr[r1];
        arr[r1] = arr[r2];
        arr[r2] = temp;
    }
}

public static void main(String[] args) {
    int[][] arr = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    swapRow(arr, 0, 2);
    // 交换第0行和第2行后，再遍历看看结果
    for (int row = 0; row < arr.length; row++) {
        System.out.println(Arrays.toString(arr[row]));
    }
}

执行结果：

[9, 10, 11, 12]
[5, 6, 7, 8]
[1, 2, 3, 4]

可以看到，仅仅通过交换“外层数组”中的两个引用，便实现了二维数组行的整体交换，这就是“数组的数组”在内存布局上的灵活性体现。

六、总结与展望

本文详细介绍了数组的基本概念与操作方法，从数组的定义、创建、初始化到元素的访问、遍历，以及数组作为方法参数和返回值的使用，都进行了系统的阐述。特别是对于一维数组和二维数组的讲解，不仅展示了它们在内存中的存储结构，还通过示例说明了数组的灵活性，如行交换操作。同时，通过比较基本数据类型与引用数据类型的区别，帮助读者更好地理解数组在Java中的作用和局限性。

通过本文的学习，希望能为大家打下坚实的数组操作基础，并为今后在更高级的数据结构和Java编程技术上的探索提供思路和方向。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-05-06，如有侵权请联系 cloudcommunity@tencent.com 删除

java