五、Java数组的定义、操作与应用场景
5.1 学习目标与重点提示
学习目标：掌握Java数组的定义、初始化、遍历、排序等操作方法，了解数组的存储结构和内存分配，学会在实际开发中运用数组解决问题。
重点：数组的定义与初始化 、数组的遍历（for循环、for-each循环） 、数组的常用操作（添加、删除、修改、查找） 、数组的排序（冒泡排序、选择排序、插入排序） 、数组的存储结构和内存分配。
5.2 数组的定义与初始化
数组是Java中一种用于存储相同类型数据的容器。
5.2.1 数组的定义
定义 ：数组的定义是指定义数组的类型和名称。
语法：
java
数据类型[] 数组名;示例：
java
int[] scores;
String[] names;✅ 结论：数组的定义是指定义数组的类型和名称。
5.2.2 数组的初始化
定义 ：数组的初始化是指给数组分配内存空间并赋值。
分类：
- 静态初始化：在定义数组时直接赋值。
- 动态初始化：在定义数组时只分配内存空间，然后赋值。
示例：
java
// 静态初始化
int[] scores = {85, 90, 95, 80, 75};
String[] names = {"张三", "李四", "王五", "赵六", "钱七"};
// 动态初始化
int[] ages = new int[5];
ages[0] = 20;
ages[1] = 21;
ages[2] = 22;
ages[3] = 23;
ages[4] = 24;✅ 结论：数组的初始化是指给数组分配内存空间并赋值，分为静态初始化和动态初始化。
5.3 数组的遍历
数组的遍历是指访问数组中的每一个元素。
5.3.1 使用for循环遍历数组
定义 ：使用for循环遍历数组是指使用for循环访问数组中的每一个元素。
示例：
java
public class ForLoopTraversal {
public static void main(String[] args) {
int[] scores = {85, 90, 95, 80, 75};
for (int i = 0; i < scores.length; i++) {
System.out.println("第" + (i + 1) + "个学生的成绩：" + scores[i]);
}
}
}输出结果：
第1个学生的成绩：85
第2个学生的成绩：90
第3个学生的成绩：95
第4个学生的成绩：80
第5个学生的成绩：75✅ 结论：使用for循环遍历数组是指使用for循环访问数组中的每一个元素。
5.3.2 使用for-each循环遍历数组
定义 ：使用for-each循环遍历数组是指使用for-each循环访问数组中的每一个元素。
示例：
java
public class ForEachTraversal {
public static void main(String[] args) {
int[] scores = {85, 90, 95, 80, 75};
for (int score : scores) {
System.out.println("学生的成绩：" + score);
}
}
}输出结果：
学生的成绩：85
学生的成绩：90
学生的成绩：95
学生的成绩：80
学生的成绩：75✅ 结论：使用for-each循环遍历数组是指使用for-each循环访问数组中的每一个元素。
5.4 数组的常用操作
数组的常用操作包括添加、删除、修改、查找等。
5.4.1 添加元素
定义 ：添加元素是指向数组中添加一个元素。
示例：
java
public class AddElement {
public static void main(String[] args) {
int[] scores = {85, 90, 95, 80, 75};
int[] newScores = new int[scores.length + 1];
for (int i = 0; i < scores.length; i++) {
newScores[i] = scores[i];
}
newScores[scores.length] = 88;
for (int score : newScores) {
System.out.println("学生的成绩：" + score);
}
}
}输出结果：
学生的成绩：85
学生的成绩：90
学生的成绩：95
学生的成绩：80
学生的成绩：75
学生的成绩：88✅ 结论：添加元素是指向数组中添加一个元素，需要创建一个新数组并复制原数组的元素。
5.4.2 删除元素
定义 ：删除元素是指从数组中删除一个元素。
示例：
java
public class RemoveElement {
public static void main(String[] args) {
int[] scores = {85, 90, 95, 80, 75};
int[] newScores = new int[scores.length - 1];
int index = 2;
for (int i = 0; i < newScores.length; i++) {
if (i < index) {
newScores[i] = scores[i];
} else {
newScores[i] = scores[i + 1];
}
}
for (int score : newScores) {
System.out.println("学生的成绩：" + score);
}
}
}输出结果：
学生的成绩：85
学生的成绩：90
学生的成绩：80
学生的成绩：75✅ 结论：删除元素是指从数组中删除一个元素，需要创建一个新数组并复制原数组的元素。
5.4.3 修改元素
定义 ：修改元素是指修改数组中的一个元素。
示例：
java
public class ModifyElement {
public static void main(String[] args) {
int[] scores = {85, 90, 95, 80, 75};
scores[2] = 92;
for (int score : scores) {
System.out.println("学生的成绩：" + score);
}
}
}输出结果：
学生的成绩：85
学生的成绩：90
学生的成绩：92
学生的成绩：80
学生的成绩：75✅ 结论：修改元素是指修改数组中的一个元素，直接通过数组的索引修改元素的值。
5.4.4 查找元素
定义 ：查找元素是指在数组中查找一个元素。
示例：
java
public class FindElement {
public static void main(String[] args) {
int[] scores = {85, 90, 95, 80, 75};
int target = 95;
int index = -1;
for (int i = 0; i < scores.length; i++) {
if (scores[i] == target) {
index = i;
break;
}
}
if (index != -1) {
System.out.println("目标元素的索引：" + index);
} else {
System.out.println("目标元素未找到");
}
}
}输出结果：
目标元素的索引：2✅ 结论：查找元素是指在数组中查找一个元素，通过循环遍历数组中的元素进行判断。
5.5 数组的排序
数组的排序是指对数组中的元素进行排序。
5.5.1 冒泡排序
定义 ：冒泡排序是一种简单的排序算法，通过重复比较相邻的元素并交换位置来实现排序。
示例：
java
public class BubbleSort {
public static void main(String[] args) {
int[] scores = {85, 90, 95, 80, 75};
for (int i = 0; i < scores.length - 1; i++) {
for (int j = 0; j < scores.length - 1 - i; j++) {
if (scores[j] > scores[j + 1]) {
int temp = scores[j];
scores[j] = scores[j + 1];
scores[j + 1] = temp;
}
}
}
for (int score : scores) {
System.out.println("学生的成绩：" + score);
}
}
}输出结果：
学生的成绩：75
学生的成绩：80
学生的成绩：85
学生的成绩：90
学生的成绩：95✅ 结论：冒泡排序是一种简单的排序算法，通过重复比较相邻的元素并交换位置来实现排序。
5.5.2 选择排序
定义 ：选择排序是一种简单的排序算法，通过选择最小的元素并交换位置来实现排序。
示例：
java
public class SelectionSort {
public static void main(String[] args) {
int[] scores = {85, 90, 95, 80, 75};
for (int i = 0; i < scores.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < scores.length; j++) {
if (scores[j] < scores[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
int temp = scores[i];
scores[i] = scores[minIndex];
scores[minIndex] = temp;
}
}
for (int score : scores) {
System.out.println("学生的成绩：" + score);
}
}
}输出结果：
学生的成绩：75
学生的成绩：80
学生的成绩：85
学生的成绩：90
学生的成绩：95✅ 结论：选择排序是一种简单的排序算法，通过选择最小的元素并交换位置来实现排序。
5.5.3 插入排序
定义 ：插入排序是一种简单的排序算法，通过将元素插入到已排序的数组中实现排序。
示例：
java
public class InsertionSort {
public static void main(String[] args) {
int[] scores = {85, 90, 95, 80, 75};
for (int i = 1; i < scores.length; i++) {
int temp = scores[i];
int j = i - 1;
while (j >= 0 && scores[j] > temp) {
scores[j + 1] = scores[j];
j--;
}
scores[j + 1] = temp;
}
for (int score : scores) {
System.out.println("学生的成绩：" + score);
}
}
}输出结果：
学生的成绩：75
学生的成绩：80
学生的成绩：85
学生的成绩：90
学生的成绩：95✅ 结论：插入排序是一种简单的排序算法，通过将元素插入到已排序的数组中实现排序。
5.6 数组的存储结构和内存分配
数组的存储结构是指数组在内存中的存储方式。
5.6.1 数组的存储结构
定义 ：数组的存储结构是指数组在内存中的存储方式。
特点：
- 数组中的元素在内存中连续存储。
- 数组的索引是数组元素在内存中的偏移量。
示例：
java
int[] scores = {85, 90, 95, 80, 75};存储结构：
┌───────────────────────────────────────────────────────────┐
│ 内存地址 │
├───────────────────────────────────────────────────────────┤
│ 0x001 → 85 │ 0x002 → 90 │ 0x003 → 95 │ 0x004 → 80 │ 0x005 → 75 │
└───────────────────────────────────────────────────────────┘✅ 结论：数组的存储结构是指数组在内存中的存储方式，数组中的元素在内存中连续存储。
5.6.2 数组的内存分配
定义 ：数组的内存分配是指给数组分配内存空间的过程。
特点：
- 数组的内存分配是在堆内存中进行的。
- 数组的引用是存储在栈内存中的。
示例：
java
int[] scores = {85, 90, 95, 80, 75};内存分配：
┌───────────────────────────────────────────────────────────┐
│ 栈内存 │
├───────────────────────────────────────────────────────────┤
│ scores → 0x100 │
└───────────────────────────────────────────────────────────┘
┌───────────────────────────────────────────────────────────┐
│ 堆内存 │
├───────────────────────────────────────────────────────────┤
│ 0x100 → {85, 90, 95, 80, 75} │
└───────────────────────────────────────────────────────────┘✅ 结论：数组的内存分配是指给数组分配内存空间的过程，数组的内存分配是在堆内存中进行的，数组的引用是存储在栈内存中的。
5.7 实际开发中的应用场景
在实际开发中，数组的应用场景非常广泛，如：
- 存储学生成绩。
- 存储员工信息。
- 存储商品价格。
- 存储图像像素。
示例：
java
public class ApplicationExample {
public static void main(String[] args) {
// 计算学生成绩的平均值
int[] scores = {85, 90, 95, 80, 75};
int sum = 0;
for (int score : scores) {
sum += score;
}
double average = sum / scores.length;
System.out.println("学生成绩的平均值：" + average);
// 查找学生成绩中的最大值和最小值
int maxScore = scores[0];
int minScore = scores[0];
for (int score : scores) {
if (score > maxScore) {
maxScore = score;
}
if (score < minScore) {
minScore = score;
}
}
System.out.println("学生成绩的最大值：" + maxScore);
System.out.println("学生成绩的最小值：" + minScore);
// 统计学生成绩的分布
int[] distribution = new int[5];
for (int score : scores) {
if (score >= 90) {
distribution[0]++;
} else if (score >= 80) {
distribution[1]++;
} else if (score >= 70) {
distribution[2]++;
} else if (score >= 60) {
distribution[3]++;
} else {
distribution[4]++;
}
}
System.out.println("90分以上的学生人数：" + distribution[0]);
System.out.println("80分以上的学生人数：" + distribution[1]);
System.out.println("70分以上的学生人数：" + distribution[2]);
System.out.println("60分以上的学生人数：" + distribution[3]);
System.out.println("60分以下的学生人数：" + distribution[4]);
}
}输出结果：
学生成绩的平均值：85.0
学生成绩的最大值：95
学生成绩的最小值：75
90分以上的学生人数：2
80分以上的学生人数：2
70分以上的学生人数：1
60分以上的学生人数：0
60分以下的学生人数：0✅ 结论：在实际开发中，数组的应用场景非常广泛，需要根据实际问题选择合适的数组操作方法。
总结
本章我们学习了Java数组的定义、操作与应用场景，包括数组的定义与初始化、数组的遍历、数组的常用操作、数组的排序、数组的存储结构和内存分配。其中，数组的定义与初始化、数组的遍历（for循环、for-each循环）、数组的常用操作（添加、删除、修改、查找）、数组的排序（冒泡排序、选择排序、插入排序）、数组的存储结构和内存分配是本章的重点内容。从下一章开始，我们将学习Java的面向对象编程、集合等内容。