Java 数组定义、初始化与操作详解

温以宁

发布时间：2026-10-13 | 6人浏览过

原创

Java 数组是一组相同数据类型变量的集合，能够高效管理批量数据。本文将深入解析数组的内存管理机制，详细介绍一维与二维数组的声明、动态/静态初始化方法，以及获取长度、遍历、查找极值和排序等核心操作技巧。

结果或目标

掌握 Java 中数组的正确使用方式，理解其底层内存模型，并能够熟练进行数组的创建、赋值、访问及基本逻辑处理。

准备条件

开发环境需支持 Java 语法（如 JDK 1.8+），具备基础的面向对象编程概念，了解基本数据类型（int, long, char 等）与引用类型的区别。

真实操作顺序

第 1 步：理解数组的内存布局与默认值

目的：明确数组在内存中的分配位置及初始化状态，避免空指针异常或未初始化值的误用。

原理：

栈内存（Stack）：存放数组的名称（引用变量）。
堆内存（Heap）：存放数组的实际元素数据。必须使用 new 关键字才能在堆中开辟空间。

重要参数与现象：

整型（int）、浮点型等基本数据类型的数组元素默认值为 0。
引用类型（如对象数组）的默认值为 null。
若仅声明未分配内存（如 int[] a;），直接访问会导致 NullPointerException。

第 2 步：一维数组的声明与动态初始化

目的：创建一个指定长度、元素由系统赋予默认值的数组。

操作步骤：

声明数组：数据类型 [] 数组名 = null;
分配内存：数组名 = new 数据类型[长度];

代码示例：

package com.qn.array;

public class Test {
    public static void main(String[] args) {
        // 1. 声明数组
        int score[] = null;
        
        // 2. 开辟空间，大小为3，此时元素全为0
        score = new int[3];
        
        // 验证默认值
        System.out.print("score[0]=" + score[0]);
        System.out.print("\tscore[1]=" + score[1]);
        System.out.print("\tscore[2]=" + score[2]);
    }
}

第 3 步：一维数组的合并声明与静态初始化

目的：在创建数组的同时直接指定具体元素内容，适用于已知数据的场景。

操作入口：使用大括号 {} 包裹初始值。

代码示例：

package com.qn.array;

public class Test {
    public static void main(String[] args) {
        // 静态初始化：直接赋值
        int score[] = {1, 2, 3, 4, 5, 6};
        
        // 获取长度
        System.out.println(score.length); // 输出: 6
    }
}

第 4 步：数组的长度获取与元素访问

目的：动态获取数组容量并按索引读取数据。

关键规则：

长度属性：使用 数组名.length 获取，返回类型为 int。注意区分与方法调用（无需括号）。
索引范围：Java 数组索引从 0 开始，最大索引为 length - 1。越界访问将抛出 ArrayIndexOutOfBoundsException。

操作演示：

// 访问第一个元素
System.out.println(score[0]);
// 访问最后一个元素
System.out.println(score[score.length - 1]);

第 5 步：查找数组中的最大值和最小值

目的：通过遍历算法筛选出数组中的极值元素。

操作步骤：

假设第一个元素为当前最大值和最小值。
使用 for 循环从第二个元素开始遍历。
对比每个元素与当前极值的大小，更新极值变量。

代码示例：

package com.qn.array;

public class Test {
    public static void main(String[] args) {
        int score[] = {45, 12, 8, 23, 89, 56};
        int max = score[0];
        int min = score[0];
        
        for (int i = 1; i < score.length; i++) {
            if (score[i] > max) {
                max = score[i];
            }
            if (score[i] < min) {
                min = score[i];
            }
        }
        
        System.out.println("最大值:" + max);
        System.out.println("最小值:" + min);
    }
}

第 6 步：数组的基础排序（冒泡/选择思想）

目的：对数组元素按降序排列，展示嵌套循环的应用。

操作步骤：

外层循环控制比较轮数。
内层循环负责相邻或特定元素的比较与交换。

代码示例（降序）：

package com.qn.array;

public class Test {
    public static void main(String[] args) {
        int score[] = {45, 12, 8, 23, 89, 56};
        int temp = 0;
        
        // 双重循环进行两两比较交换
        for (int i = 0; i < score.length; i++) {
            for (int j = 0; j < score.length - 1; j++) {
                if (score[i] > score[j]) {
                    temp = score[i];
                    score[i] = score[j];
                    score[j] = temp;
                }
            }
        }
        
        // 输出排序后的结果
        for (int i = 0; i < score.length; i++) {
            System.out.print(score[i] + "\t");
        }
    }
}

第 7 步：二维数组的声明与初始化

目的：处理表格状的多维数据结构。

操作分类：

动态初始化：数据类型数组名[][] = new 数据类型[行][列];。需明确行列数量。
静态初始化：数据类型数组名[][] = {{...}, {...}};。自动推断行列。

内存消耗计算：

对于 int[][] arr = new int[4][3];，总元素数为 4 * 3 = 12。若 int 占 4 字节，则占用内存约为 48 字节（不含对象头开销）。

第 8 步：多维数组的访问

目的：通过多级索引定位深层数据。

注意事项：

Java 中多维数组本质是“数组的数组”，因此 arr[i] 的长度可以不同（锯齿数组）。
遍历时建议使用 arr[i].length 而非固定列数，以适应不规则结构。

代码示例：

package com.qn.array;

public class test1 {
    public static void main(String[] args) {
        int score[][] = new int[4][3];
        
        // 赋值示例
        score[0][1] = 30;
        score[1][0] = 31;
        
        // 嵌套循环遍历
        for (int i = 0; i < score.length; i++) {
            for (int j = 0; j < score[i].length; j++) {
                System.out.print(score[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

第 9 步：三维数组概览

目的：了解更高维度的数据结构形态。

操作说明：

虽然日常开发中较少直接使用三维及以上数组，但理解其作为“立方体”或“多层表格”的逻辑至关重要。初始化时需确保每一层的维度对齐。

代码示例：

package com.qn.array;

public class test1 {
    public static void main(String[] args) {
        // 静态初始化三维数组
        int score[][][] = {
            { {5, 1}, {6, 7} },
            { {9, 4}, {8, 3} }
        };
        
        // 访问特定元素
        System.out.print(score[0][0][0] + "\t"); // 输出: 5
        System.out.print(score[1][1][1] + "\t"); // 输出: 3
    }
}