【Java基础知识 16】 数组详解

数组：用来存储大批量数据的容器

---

一、数组概述

数组是 Java 中最基础的数据结构之一，它是一种用于存储批量同类型数据的容器。相比单独定义多个变量，数组能更高效地管理和操作一组相关数据，尤其适合处理具有相同类型和相似用途的数据集合（如学生成绩、用户列表等）。

数组的核心特点：

• 存储的数据类型必须统一（如 int 数组只能存整数，String 数组只能存字符串）
• 数据在内存中连续存储，通过索引快速访问
• 一旦创建，长度不可改变（但元素值可以修改）

---

二、静态初始化数组

静态初始化适用于创建数组时已知所有元素值的场景，定义时直接指定数组内容。

1.定义格式

静态初始化有两种常用写法，推荐使用第一种（更符合 Java 编码规范）：

//静态初始化数组，定义时已经确定了数据
数据类型[] 数组名 = {元素1,元素2,元素3，...};
int[] arr = {6,11,13};

//完整格式
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3，...};
int[] arr = new int[]{6,11,13};

注意：中括号[]也可放在数组名后（如int numbers[]），但不推荐，这是 C 语言风格的写法，不符合 Java 规范。

2. 内存存储原理：

数组在内存中是连续的存储空间，每个元素按顺序排列，通过索引（从 0 开始）定位。

• 数组变量arr存储的是数组在内存中的首地址
• 索引 0 对应第一个元素，索引 1 对应第二个元素，以此类推
• 访问任意元素的时间复杂度为 O (1)，效率极高

3. 数组的基本操作

（1）访问元素

通过数组名[索引]访问指定位置的元素：

数组名[索引]
System.out.println(arr[0]);//6（访问第一个元素）
System.out.println(arr[2]);//13（访问第三个元素）

（2）修改元素

通过索引重新赋值即可修改元素：

arr[1] = 100;//将11改为100
System.out.println(arr[1]); // 输出：100

（3）获取长度

通过数组名.length获取数组中元素的个数：

System.out.println(arr.length);

4. 实战案例：随机点名系统

public class Demo {public static void main(String[] args) {//目标：认识到使用数组的好处，数组的定义、访问callStudent();}//开发一个随机点名的方法public static  void callStudent() {//1.定义一个数组，保存15个学生//静态初始化数组：定义数组的时候，数据已经定义好了// String[] names = {"小王", "小李", "小张", "小赵", "小钱", "小孙", "张三", "李四", "王五", "小明", "小红", "小吴", "小杨", "小东","小小张"};//完整定义方式// String[] names = new String[]{"小王", "小李", "小张", "小赵", "小钱", "小孙", "张三", "李四", "王五", "小明", "小红", "小吴", "小杨", "小东","小小张"};//中括号也可以放在数组变量的后面定义String names[] = {"小王", "小李", "小张", "小赵", "小钱", "小孙", "张三", "李四", "王五", "小明", "小红", "小吴", "小杨", "小东","小小张"};//         索引     0       1       2      3      4      5      6      7       8      9      10     11     12      13     14//2.随机获取一个索引值//Math.random()：[0,1）之间的小数//names.length：数组中元素的个数（15)int index = (int)(Math.random() * names.length);// [0,15)---强转为int后值为：[0-14]//3.根据索引值，获取数组中的元素：数组名[索引值]String name = names[index];System.out.println( name);}
}

案例说明：
通过静态初始化直接定义学生列表，利用Random类生成随机索引，实现随机点名功能。相比单独定义 15 个变量，数组使代码更简洁、扩展性更强（如需增加学生，只需在数组中添加元素）。

---

三、动态初始化数组

动态初始化适用于创建数组时已知长度，但不确定具体元素值的场景，定义时先指定数组长度，后续再填充数据。

1.定义格式

数据类型[] 数组名 = new 数据类型[长度];

示例：

// 定义一个能存储5个整数的数组
int[] scores = new int[5];// 定义一个能存储3个浮点数的数组
double[] weights = new double[3];

2. 元素默认值规则

动态初始化的数组会自动为元素赋予默认值，规则如下：

示例验证：

public class DefaultValueDemo {public static void main(String[] args) {int[] intArr = new int[3];System.out.println(intArr[0]); // 输出：0（整数默认值）boolean[] boolArr = new boolean[2];System.out.println(boolArr[0]); // 输出：false（布尔默认值）String[] strArr = new String[2];System.out.println(strArr[0]); // 输出：null（引用类型默认值）}
}

3.数组的遍历

遍历是指逐个访问数组中的所有元素，是数组操作的核心技能，常用于求和、查找、筛选等场景。
（1）普通 for 循环遍历（推荐，可修改元素）

int[] arr = {20, 30, 40, 50};
for (int i = 0; i < arr.length; i++) {System.out.println("索引" + i + "的值：" + arr[i]);
}

（2）增强 for 循环遍历（仅用于读取元素）

for (int num : arr) { // 简化写法，直接获取元素值System.out.println("元素值：" + num);
}

4.实战案例：成绩统计系统

public class Demo {public static void main(String[] args) {//目标：掌握动态初始化数组inputScore();}//设计一个方法录入学生成绩，并计算总分、平均分、最高分、最低分public static void inputScore() {//1.定义一个数组，用来保存录入的8个学生成绩//动态初始化数组，只确定数组的数据类型和长度//数据类型[] 数组名 = new 数据类型[数组的长度];double[] scores = new double[8];// scores = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]//     索引    0    1    2    3    4    5    6    7//2.录入8个学生成绩，存入数组中Scanner scanner = new Scanner(System.in);for (int i = 0; i < scores.length; i++) {// i = 0 1 2 3 4 5 6 7System.out.println("请输入第" + (i + 1) + "个学生的成绩：");scores[i] = scanner.nextDouble();}//3.遍历数组，统计总分，平均分double sum = 0.0;for (int i = 0; i < scores.length; i++) {// i = 0 1 2 3 4 5 6 7double score = scores[i];//4.累加当前遍历的成绩sum += score;}System.out.println("总分为：" + sum);System.out.println("平均分为：" + sum / scores.length);//最高分//定义一个变量，作为当前最大值（建议使用第一个数据作为参照值）double max = scores[0];//从数组的第二个数据开始遍历for (int i = 1; i < scores.length; i++) {double score = scores[i];//依次与参照值进行比较，如果比参照值大，则更新最大值if (score > max) {max = score;}}System.out.println("最高分为：" + max);//最低分double min = scores[0];for (int i = 1; i < scores.length; i++) {if (scores[i]< min){min = scores[i];}}System.out.println("最低分为：" + min);}
}

案例说明：
通过动态初始化创建指定长度的数组，结合循环录入成绩（带输入验证确保数据合法性），再通过一次遍历完成所有统计计算，体现了数组在批量数据处理中的高效性。

---

四、二维数组

二维数组是元素为一维数组的数组，可理解为 “数组的数组”，常用于表示表格、矩阵等二维结构（如多行多列的学生信息表）。

1.定义格式

（1）静态初始化

适用于已知所有元素的场景：

// 简化格式
数据类型[][] 数组名 = {{元素1, 元素2}, {元素3, 元素4}, ...};// 完整格式
数据类型[][] 数组名 = new 数据类型[][]{{元素1, 元素2}, {元素3, 元素4}, ...};

示例：

// 定义一个2行3列的整数二维数组
int[][] matrix = {{1, 2, 3},{4, 5, 6}
};

（2）动态初始化

• 方式 1：指定行数和列数（每行长度相同）

数据类型[][] 数组名 = new 数据类型[行数][列数];
int[][] arr = new int[2][3]; // 2行3列的二维数组

• 方式 2：先指定行数，后续再定义每行长度（每行长度可不同，称为 “不规则数组”）

int[][] arr = new int[3][]; // 3行，列数暂不指定
arr[0] = new int[2]; // 第1行2列
arr[1] = new int[4]; // 第2行4列
arr[2] = new int[3]; // 第3行3列

2.基本操作

（1）访问元素

通过数组名[行索引][列索引]访问：

int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
System.out.println(matrix[0][1]); // 输出：2（第1行第2列）
System.out.println(matrix[1][2]); // 输出：6（第2行第3列）

（2）获取长度

• 数组名.length：获取行数
• 数组名[行索引].length：获取指定行的列数

System.out.println(matrix.length); // 输出：2（共2行）
System.out.println(matrix[0].length); // 输出：3（第1行有3列）

3. 遍历二维数组

需使用嵌套循环，外层循环遍历行，内层循环遍历列：

int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};// 普通for循环遍历
for (int i = 0; i < matrix.length; i++) { // 遍历行for (int j = 0; j < matrix[i].length; j++) { // 遍历列System.out.print(matrix[i][j] + " ");}System.out.println(); // 换行
}// 增强for循环遍历
for (int[] row : matrix) { // 每行是一个一维数组for (int num : row) { // 遍历行中的元素System.out.print(num + " ");}System.out.println();
}

4. 实战案例：班级座位表

public class Demo {public static void main(String[] args) {//目标：创建二维数组printArray();}public static void printArray() {//初始化二维数组，存储学生姓名，考录到座位不规则，直接定义每排的座位//动态初始化数组String[][] name = {{"小王", "小张", "小李"},//0  第一排{"小明", "小小明", "小小小明"},//1  第二排{"小李", "小小李", "小小小李", "小小小小李"},//2  第三排{"小张", "小小张"},//3  第四排};//静态初始化数组String[][] name1 = new String[4][3];//4行3列//访问：数组名[行索引]String[] names = name[2];//循环遍历for (int i = 0; i < names.length; i++) {System.out.println(names[i]);}System.out.println("------------------------");//访问：数组名[行索引][列索引]System.out.println(name[1][1]);System.out.println(name[2][2]);System.out.println("---------------");//长度访问：数组名.length 访问行数System.out.println(name.length);//4System.out.println(name[1].length);//3System.out.println("---------------");//遍历二维数组for (int i = 0; i < name.length; i++) {//i 行索引 0 1 2 3String[] names2 = name[i];for (int j = 0; j < names2.length; j++) {System.out.print(names2[j]+"\t");}System.out.println();}}
}

案例说明：
利用不规则二维数组表示不同长度的座位排，通过格式化输出使表格更清晰，同时添加空指针检查增强代码健壮性，适合处理类似 “行数固定但每行元素数量不同” 的场景。

---

五、数组常见问题与注意事项

• 索引越界异常（ArrayIndexOutOfBoundsException）
  访问索引超出[0, 长度-1]范围时抛出，例如int[] arr = new int[3]; arr[3] = 10;（索引 3 超出范围）。
• 空指针异常（NullPointerException）
  数组未初始化或被赋值为null时访问元素，例如String[] arr = null; System.out.println(arr[0]);。
• 数组长度不可变
  数组一旦创建，长度无法修改，如需动态增减元素，需使用ArrayList等集合类。
• 数组与集合的选择
  数组：适合长度固定、类型统一、频繁访问元素的场景，效率更高。
  集合（如ArrayList）：适合长度不确定、需要动态增删元素的场景，更灵活。

---

总结

数组是 Java 中处理批量数据的基础工具，掌握其初始化方式（静态 / 动态）、基本操作（访问、修改、遍历）和二维数组的应用，能显著提升代码效率和可读性。无论是简单的数值统计还是复杂的表格数据处理，数组都能发挥重要作用。在实际开发中，需根据数据特点选择合适的初始化方式，并注意避免索引越界和空指针等常见异常。