跳到主要内容

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[] arrayint 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数组的操作:

  1. 创建数组的多种方式
  2. 访问和修改数组元素
  3. 获取数组长度和遍历数组的方法
  4. 常用的数组操作方法(复制、排序、查找、填充、比较)
  5. 多维数组的使用
  6. 数组在实际场景中的应用

数组是Java中最基础的数据结构,掌握数组操作是进一步学习Java集合框架和更高级数据结构的基础。建议初学者多练习数组操作,熟悉各种方法的使用场景。

练习题

为了巩固所学知识,请尝试完成以下练习:

  1. 编写程序,创建一个包含10个整数的数组,将每个元素设置为其索引值的平方,然后打印数组内容。
  2. 编写程序,找出数组中的最大值和最小值,以及它们的位置。
  3. 编写程序,实现两个数组的合并。
  4. 编写程序,将数组中的元素反转。
  5. 编写程序,使用二维数组存储一个3x3的矩阵,然后计算矩阵的转置。

扩展资源

要深入学习Java数组,可以参考以下资源:

  • Java官方API文档中的java.util.Arrays
  • 《Java编程思想》中关于数组的章节
  • 《Java核心技术》中数据结构相关内容

随着编程经验的积累,你会发现数组虽然简单,但在处理大量数据和算法实现中起着至关重要的作用。