第18章
Java数组基础
掌握数组的声明、创建、初始化和基本操作方法
学习目标
理解数组的概念和特点
掌握数组的声明语法
学会数组的创建和内存分配
掌握数组的初始化方法
了解数组的内存模型
学会数组的基本操作和最佳实践
什么是数组
数组是Java中最基本的数据结构之一，它是一个容器，可以存储多个相同类型的数据元素。数组中的每个元素都有一个索引（下标），通过索引可以访问和操作数组中的元素。
数组的特点
类型统一：数组中所有元素必须是相同的数据类型
长度固定：数组一旦创建，长度就不能改变
索引访问：通过索引（从0开始）访问数组元素
连续存储：数组元素在内存中连续存储
数组声明
在Java中，数组声明有两种语法形式，推荐使用第一种形式：
推荐语法
语法格式：
数据类型[] 数组名;
示例：
int[] numbers; // 整型数组
String[] names; // 字符串数组
double[] scores; // 双精度数组
boolean[] flags; // 布尔数组
备选语法
语法格式：
数据类型 数组名[];
示例：
int numbers[]; // 整型数组
String names[]; // 字符串数组
double scores[]; // 双精度数组
boolean flags[]; // 布尔数组
注意事项
数组声明时不能指定长度，长度是在创建数组时确定的。例如 int[5] arr; 是错误的语法。
数组创建
数组创建使用 new 关键字，需要指定数组的长度：
基本语法：
数组名 = new 数据类型[长度];
创建示例：
// 声明并创建数组
int[] numbers = new int[5]; // 创建长度为5的整型数组
String[] names = new String[10]; // 创建长度为10的字符串数组
double[] scores = new double[3]; // 创建长度为3的双精度数组
// 分步操作
int[] ages; // 先声明
ages = new int[8]; // 后创建
默认值
数组创建后，所有元素都会被初始化为默认值：
各类型默认值：
int[] numbers = new int[3]; // [0, 0, 0]
double[] scores = new double[3]; // [0.0, 0.0, 0.0]
boolean[] flags = new boolean[3]; // [false, false, false]
String[] names = new String[3]; // [null, null, null]
char[] chars = new char[3]; // ['\u0000', '\u0000', '\u0000']
数组初始化
Java提供了多种数组初始化的方法：
静态初始化
在声明数组的同时指定初始值：
完整语法：
// 方式1：完整语法
int[] numbers = new int[]{1, 2, 3, 4, 5};
String[] names = new String[]{"张三", "李四", "王五"};
double[] scores = new double[]{85.5, 92.0, 78.5};
// 方式2：简化语法（推荐）
int[] numbers = {1, 2, 3, 4, 5};
String[] names = {"张三", "李四", "王五"};
double[] scores = {85.5, 92.0, 78.5};
动态初始化
先创建数组，然后逐个赋值：
动态赋值：
// 创建数组
int[] numbers = new int[5];
// 逐个赋值
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;
// 使用循环赋值
for (int i = 0; i < numbers.length; i++) {
numbers[i] = (i + 1) * 10;
}
数组访问和操作
访问数组元素
基本访问：
int[] numbers = {10, 20, 30, 40, 50};
// 访问元素（索引从0开始）
int first = numbers[0]; // 获取第一个元素：10
int third = numbers[2]; // 获取第三个元素：30
int last = numbers[4]; // 获取最后一个元素：50
// 修改元素
numbers[1] = 25; // 将第二个元素改为25
numbers[3] = 45; // 将第四个元素改为45
// 获取数组长度
int length = numbers.length; // 数组长度：5
遍历数组
遍历方法：
int[] numbers = {10, 20, 30, 40, 50};
// 方式1：传统for循环
for (int i = 0; i < numbers.length; i++) {
System.out.println("索引 " + i + ": " + numbers[i]);
}
// 方式2：增强for循环（for-each）
for (int num : numbers) {
System.out.println("元素值: " + num);
}
// 方式3：while循环
int i = 0;
while (i < numbers.length) {
System.out.println("元素 " + i + ": " + numbers[i]);
i++;
}
数组越界异常
访问数组时要注意索引范围，有效索引为 0 到 length-1。超出范围会抛出 ArrayIndexOutOfBoundsException 异常。
int[] arr = new int[5]; // 有效索引：0, 1, 2, 3, 4
int value = arr[5]; // 错误！会抛出异常
int value = arr[-1]; // 错误！会抛出异常
数组内存模型
数组在内存中的存储
理解数组的内存模型有助于更好地使用数组：
栈内存
存储数组变量
arr
→
堆内存
存储数组对象
[10][20][30]
内存分配示例：
int[] arr = new int[]{10, 20, 30};
// 栈内存：变量arr存储数组对象的地址
// 堆内存：实际的数组对象存储在堆中
// arr[0] → 堆中第一个位置的值 10
// arr[1] → 堆中第二个位置的值 20
// arr[2] → 堆中第三个位置的值 30
完整代码示例
ArrayBasicsExample.java
/**
* Java数组基础示例
* 演示数组的声明、创建、初始化和基本操作
*/
public class ArrayBasicsExample {
public static void main(String[] args) {
// 1. 数组声明和创建
System.out.println("=== 数组声明和创建 ===");
int[] numbers = new int[5]; // 创建长度为5的整型数组
System.out.println("数组长度: " + numbers.length);
// 2. 数组初始化
System.out.println("\n=== 数组初始化 ===");
// 静态初始化
int[] scores = {85, 92, 78, 96, 88};
String[] names = {"张三", "李四", "王五", "赵六", "钱七"};
// 动态初始化
for (int i = 0; i < numbers.length; i++) {
numbers[i] = (i + 1) * 10;
}
// 3. 数组访问和遍历
System.out.println("\n=== 数组遍历 ===");
System.out.println("学生成绩信息:");
for (int i = 0; i < names.length; i++) {
System.out.println(names[i] + ": " + scores[i] + "分");
}
// 4. 使用增强for循环
System.out.println("\n=== 增强for循环 ===");
System.out.print("numbers数组: ");
for (int num : numbers) {
System.out.print(num + " ");
}
System.out.println();
// 5. 数组统计操作
System.out.println("\n=== 数组统计 ===");
int sum = 0;
int max = scores[0];
int min = scores[0];
for (int score : scores) {
sum += score;
if (score > max) max = score;
if (score < min) min = score;
}
double average = (double) sum / scores.length;
System.out.println("总分: " + sum);
System.out.println("平均分: " + String.format("%.2f", average));
System.out.println("最高分: " + max);
System.out.println("最低分: " + min);
// 6. 数组查找
System.out.println("\n=== 数组查找 ===");
int target = 92;
int index = findElement(scores, target);
if (index != -1) {
System.out.println("找到元素 " + target + "，位置: " + index);
} else {
System.out.println("未找到元素 " + target);
}
}
/**
* 在数组中查找指定元素
* @param arr 要搜索的数组
* @param target 目标元素
* @return 元素的索引，如果未找到返回-1
*/
public static int findElement(int[] arr, int target) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == target) {
return i;
}
}
return -1;
}
}
💻 查看完整代码 - 在线IDE体验
数组使用最佳实践
编程建议
推荐做法
使用 数据类型[] 数组名 的声明方式
访问数组前检查索引范围
使用 array.length 获取数组长度
优先使用增强for循环遍历
给数组变量起有意义的名字
合理估算数组大小避免浪费
避免做法
不检查数组边界直接访问
使用魔法数字作为数组长度
在循环中重复计算 array.length
忽略数组的默认初始化值
混用不同的数组声明语法
创建过大的数组造成内存浪费
本章总结
数组是存储相同类型数据的容器，长度固定，索引从0开始
数组声明推荐使用 数据类型[] 数组名 的语法
数组创建使用 new 关键字，需要指定长度
数组初始化可以使用静态初始化或动态初始化
数组访问通过索引进行，要注意避免数组越界
数组变量存储在栈中，数组对象存储在堆中
遍历数组可以使用传统for循环或增强for循环
编程时要注意数组边界检查和合理的命名规范
上一章：break和continue
章节测试
下一章：多维数组