Java 数组操作
数组是Java中最基础也是最常用的数据结构之一，它允许我们在一个变量中存储多个相同类型的值。掌握数组操作是成为Java开发者的基础技能，本文将全面介绍Java数组的操作方法。
什么是Java数组
数组是一种用于存储同类型数据的容器，它在内存中占用连续的空间。Java数组具有以下特点：
- 数组长度固定，一旦创建就不能改变大小
- 数组元素类型必须相同
- 数组元素具有默认初始值（数值型为0，布尔型为false，引用类型为null）
- 数组索引从0开始
创建数组
在Java中，创建数组有多种方式：
1. 声明并分配内存
java
// 声明一个整型数组，可容纳5个元素
int[] numbers = new int[5];
// 声明一个字符串数组，可容纳3个元素
String[] names = new String[3];
2. 声明并初始化
java
// 声明并直接初始化一个整型数组
int[] scores = {95, 85, 75, 90, 100};
// 声明并直接初始化一个字符串数组
String[] fruits = {"Apple", "Banana", "Orange"};
3. 先声明后初始化
java
// 先声明
int[] prices;
// 后分配内存
prices = new int[4];
// 逐个赋值
prices[0] = 10;
prices[1] = 20;
prices[2] = 30;
prices[3] = 40;
备注
Java中数组声明有两种方式：int[] array 和 int array[]，推荐使用第一种方式，更清晰地表明这是一个整型数组。
访问数组元素
数组元素通过索引访问，索引从0开始：
java
int[] numbers = {10, 20, 30, 40, 50};
// 访问第一个元素
System.out.println("第一个元素: " + numbers[0]); // 输出：第一个元素: 10
// 访问第三个元素
System.out.println("第三个元素: " + numbers[2]); // 输出：第三个元素: 30
// 修改第五个元素
numbers[4] = 500;
System.out.println("修改后的第五个元素: " + numbers[4]); // 输出：修改后的第五个元素: 500
警告
尝试访问超出数组范围的索引会导致ArrayIndexOutOfBoundsException异常。例如，对于长度为5的数组，访问numbers[5]会抛出异常。
获取数组长度
使用数组的length属性可以获取数组的长度：
java
int[] numbers = {10, 20, 30, 40, 50};
System.out.println("数组长度: " + numbers.length); // 输出：数组长度: 5
遍历数组
遍历数组有多种方式：
1. 使用for循环
java
int[] numbers = {10, 20, 30, 40, 50};
System.out.println("使用for循环遍历数组:");
for (int i = 0; i < numbers.length; i++) {
System.out.println("索引 " + i + " 的元素值: " + numbers[i]);
}
输出：
使用for循环遍历数组:
索引 0 的元素值: 10
索引 1 的元素值: 20
索引 2 的元素值: 30
索引 3 的元素值: 40
索引 4 的元素值: 50
2. 使用增强for循环（for-each）
java
int[] numbers = {10, 20, 30, 40, 50};
System.out.println("使用增强for循环遍历数组:");
for (int number : numbers) {
System.out.println("元素值: " + number);
}
输出：
使用增强for循环遍历数组:
元素值: 10
元素值: 20
元素值: 30
元素值: 40
元素值: 50
提示
增强for循环（for-each）更简洁，但不能获取元素索引，也不能修改数组中的元素。当只需要读取元素时，推荐使用增强for循环。
数组操作
复制数组
Java提供了多种复制数组的方法：
1. 使用System.arraycopy()方法
java
int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[5];
System.arraycopy(source, 0, destination, 0, source.length);
System.out.println("复制后的数组:");
for (int num : destination) {
System.out.print(num + " ");
}
输出：
复制后的数组:
1 2 3 4 5
2. 使用Arrays.copyOf()方法
java
int[] original = {1, 2, 3, 4, 5};
int[] copied = Arrays.copyOf(original, original.length);
System.out.println("使用Arrays.copyOf()复制:");
for (int num : copied) {
System.out.print(num + " ");
}
输出：
使用Arrays.copyOf()复制:
1 2 3 4 5
3. 使用clone()方法
java
int[] original = {1, 2, 3, 4, 5};
int[] cloned = original.clone();
System.out.println("使用clone()方法复制:");
for (int num : cloned) {
System.out.print(num + " ");
}
输出：
使用clone()方法复制:
1 2 3 4 5
数组排序
使用Arrays.sort()方法可以对数组进行排序：
java
int[] numbers = {5, 2, 9, 1, 7};
Arrays.sort(numbers);
System.out.println("排序后的数组:");
for (int num : numbers) {
System.out.print(num + " ");
}
输出：
排序后的数组:
1 2 5 7 9
数组查找
使用Arrays.binarySearch()方法可以在排序后的数组中查找元素：
java
int[] sortedNumbers = {1, 2, 5, 7, 9};
int index = Arrays.binarySearch(sortedNumbers, 5);
System.out.println("元素5在数组中的索引: " + index);
输出：
元素5在数组中的索引: 2
注意
binarySearch()只适用于已排序的数组，对未排序的数组使用此方法可能会得到错误的结果。
数组填充
使用Arrays.fill()方法可以用特定值填充数组：
java
int[] numbers = new int[5];
Arrays.fill(numbers, 10);
System.out.println("填充后的数组:");
for (int num : numbers) {
System.out.print(num + " ");
}
输出：
填充后的数组:
10 10 10 10 10
数组比较
使用Arrays.equals()方法可以比较两个数组是否相等：
java
int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};
int[] array3 = {1, 2, 4};
System.out.println("array1 和 array2 相等: " + Arrays.equals(array1, array2));
System.out.println("array1 和 array3 相等: " + Arrays.equals(array1, array3));
输出：
array1 和 array2 相等: true
array1 和 array3 相等: false
多维数组
Java支持多维数组，最常见的是二维数组：
创建二维数组
java
// 创建3行4列的二维数组
int[][] matrix = new int[3][4];
// 直接初始化二维数组
int[][] grid = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
访问二维数组元素
java
int[][] grid = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
System.out.println("访问二维数组元素:");
System.out.println("grid[0][0] = " + grid[0][0]); // 输出: grid[0][0] = 1
System.out.println("grid[1][2] = " + grid[1][2]); // 输出: grid[1][2] = 6
System.out.println("grid[2][1] = " + grid[2][1]); // 输出: grid[2][1] = 8
遍历二维数组
java
int[][] grid = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
System.out.println("遍历二维数组:");
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[i].length; j++) {
System.out.print(grid[i][j] + " ");
}
System.out.println(); // 换行
}
输出：
遍历二维数组:
1 2 3
4 5 6
7 8 9
实际应用案例
案例1：计算学生平均成绩
java
public class StudentGrades {
public static void main(String[] args) {
// 储存5名学生的成绩
double[] grades = {85.5, 92.0, 76.5, 88.0, 90.5};
double sum = 0;
// 计算总分
for (double grade : grades) {
sum += grade;
}
// 计算平均分
double average = sum / grades.length;
System.out.printf("学生平均成绩: %.2f\n", average);
// 找出最高分和最低分
double highest = grades[0];
double lowest = grades[0];
for (int i = 1; i < grades.length; i++) {
if (grades[i] > highest) {
highest = grades[i];
}
if (grades[i] < lowest) {
lowest = grades[i];
}
}
System.out.printf("最高成绩: %.2f\n", highest);
System.out.printf("最低成绩: %.2f\n", lowest);
}
}
输出：
学生平均成绩: 86.50
最高成绩: 92.00
最低成绩: 76.50
案例2：简单图书管理系统
java
public class SimpleLibrary {
public static void main(String[] args) {
// 创建图书数组
String[] books = new String[5];
books[0] = "Java编程思想";
books[1] = "Java核心技术";
books[2] = "算法导论";
books[3] = "设计模式";
books[4] = "数据结构与算法分析";
// 创建借阅状态数组（true表示已借出，false表示在库）
boolean[] borrowed = new boolean[5];
// 模拟借书
borrowed[1] = true;
borrowed[3] = true;
// 显示图书列表和借阅状态
System.out.println("图书馆藏书列表:");
System.out.println("---------------------------");
System.out.printf("%-20s %-10s\n", "书名", "状态");
System.out.println("---------------------------");
for (int i = 0; i < books.length; i++) {
String status = borrowed[i] ? "已借出" : "在库";
System.out.printf("%-20s %-10s\n", books[i], status);
}
// 统计在库和借出数量
int availableCount = 0;
for (boolean status : borrowed) {
if (!status) {
availableCount++;
}
}
System.out.println("---------------------------");
System.out.println("在库图书数量: " + availableCount);
System.out.println("借出图书数量: " + (books.length - availableCount));
}
}
输出：
图书馆藏书列表:
---------------------------
书名 状态
---------------------------
Java编程思想 在库
Java核心技术 已借出
算法导论 在库
设计模式 已借出
数据结构与算法分析 在库
---------------------------
在库图书数量: 3
借出图书数量: 2
总结
在本文中，我们全面学习了Java数组的操作：
- 创建数组的多种方式
- 访问和修改数组元素
- 获取数组长度和遍历数组的方法
- 常用的数组操作方法（复制、排序、查找、填充、比较）
- 多维数组的使用
- 数组在实际场景中的应用
数组是Java中最基础的数据结构，掌握数组操作是进一步学习Java集合框架和更高级数据结构的基础。建议初学者多练习数组操作，熟悉各种方法的使用场景。
练习题
为了巩固所学知识，请尝试完成以下练习：
- 编写程序，创建一个包含10个整数的数组，将每个元素设置为其索引值的平方，然后打印数组内容。
- 编写程序，找出数组中的最大值和最小值，以及它们的位置。
- 编写程序，实现两个数组的合并。
- 编写程序，将数组中的元素反转。
- 编写程序，使用二维数组存储一个3x3的矩阵，然后计算矩阵的转置。
扩展资源
要深入学习Java数组，可以参考以下资源：
- Java官方API文档中的
java.util.Arrays类 - 《Java编程思想》中关于数组的章节
- 《Java核心技术》中数据结构相关内容
随着编程经验的积累，你会发现数组虽然简单，但在处理大量数据和算法实现中起着至关重要的作用。