1. 数组基础：从零理解Java数组
数组是Java中最基础也是最常用的数据结构之一。记得我刚学Java时，导师说过一句话："不会用数组的程序员，就像不会用筷子的厨师。"这句话虽然夸张，但确实道出了数组的重要性。
什么是数组？简单来说，数组就是一组相同类型数据的集合。它有两个关键特性：
- 固定长度：一旦创建，大小就不能改变
- 索引访问：通过下标（从0开始）快速访问元素
java复制// 数组的两种声明方式
int[] arr1; // 推荐写法
int arr2[]; // C语言风格的写法（不推荐）
数组在内存中的存储方式很有意思。假设我们有一个int数组，JVM会在堆内存中分配一块连续的空间。比如int[] arr = new int[5]，内存布局是这样的：
code复制索引: [0] [1] [2] [3] [4]
值: [0] [0] [0] [0] [0]
地址: x00 x04 x08 x0C x10
注意：数组下标从0开始不是偶然的。这样设计可以让元素地址计算更高效：元素地址 = 首地址 + 索引×元素大小
2. 数组的创建与初始化实战
2.1 静态初始化 vs 动态初始化
Java数组初始化有两种方式，我在项目中经常要根据场景选择：
java复制// 静态初始化：创建时直接指定元素
int[] staticArr = {1, 2, 3, 4, 5};
// 动态初始化：先指定长度，后赋值
int[] dynamicArr = new int[5];
for(int i=0; i<dynamicArr.length; i++) {
dynamicArr[i] = i+1;
}
静态初始化的优点是代码简洁，适合已知所有元素的情况。而动态初始化更灵活，适合元素需要计算或从外部获取的场景。
2.2 数组越界：新手必踩的坑
我刚工作时犯过一个错误：
java复制int[] arr = new int[3];
arr[3] = 10; // ArrayIndexOutOfBoundsException
这个异常告诉我们：数组下标必须在0到length-1之间。调试这类问题时，我现在的做法是：
- 打印数组长度
- 检查循环条件是否包含等号
- 使用增强for循环避免手动控制索引
2.3 多维数组的妙用
处理表格数据时，二维数组特别有用：
java复制// 二维数组初始化
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// 遍历二维数组
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();
}
实际项目中，我常用二维数组处理图像像素、游戏地图等场景。但要注意，Java中的多维数组实际上是"数组的数组"，每行的长度可以不同。
3. 数组操作进阶技巧
3.1 数组拷贝的四种方式对比
需要复制数组时，Java提供了多个选择：
- 循环拷贝：最基础，可控性强
java复制int[] copy = new int[src.length];
for(int i=0; i<src.length; i++) {
copy[i] = src[i];
}
- System.arraycopy()：native方法，效率最高
java复制int[] copy = new int[src.length];
System.arraycopy(src, 0, copy, 0, src.length);
- Arrays.copyOf()：代码最简洁
java复制int[] copy = Arrays.copyOf(src, src.length);
- clone()：不太推荐，容易混淆
实测性能对比（100万次操作）：
| 方法 | 耗时(ms) |
|---|---|
| 循环拷贝 | 45 |
| System.arraycopy() | 12 |
| Arrays.copyOf() | 15 |
| clone() | 50 |
3.2 数组排序与搜索
Java标准库提供了强大的数组工具类：
java复制int[] numbers = {3, 1, 4, 1, 5, 9, 2, 6};
// 快速排序
Arrays.sort(numbers); // [1, 1, 2, 3, 4, 5, 6, 9]
// 二分查找（必须先排序）
int index = Arrays.binarySearch(numbers, 5); // 4
提示：对于对象数组，可以实现Comparable接口或传入Comparator来自定义排序规则
3.3 数组与集合的转换
实际开发中经常需要在数组和List之间转换：
java复制// 数组转List
String[] arr = {"a", "b", "c"};
List<String> list = Arrays.asList(arr); // 注意：返回的是固定大小的List
// List转数组
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
Integer[] numArray = numList.toArray(new Integer[0]);
这里有个坑：Arrays.asList()返回的List不支持add/remove操作。如果需要可变List，应该：
java复制List<String> realList = new ArrayList<>(Arrays.asList(arr));
4. 数组在面试中的高频考点
4.1 经典算法题解析
问题1：找出数组中重复的数字
解法1：使用HashSet（时间复杂度O(n)，空间复杂度O(n)）
java复制public int findDuplicate(int[] nums) {
Set<Integer> seen = new HashSet<>();
for(int num : nums) {
if(seen.contains(num)) {
return num;
}
seen.add(num);
}
return -1;
}
解法2：原地交换（时间复杂度O(n)，空间复杂度O(1)）
java复制public int findDuplicate(int[] nums) {
int i = 0;
while(i < nums.length) {
if(nums[i] == i) {
i++;
continue;
}
if(nums[nums[i]] == nums[i]) {
return nums[i];
}
int temp = nums[i];
nums[i] = nums[temp];
nums[temp] = temp;
}
return -1;
}
问题2：两数之和
java复制public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for(int i=0; i<nums.length; i++) {
int complement = target - nums[i];
if(map.containsKey(complement)) {
return new int[]{map.get(complement), i};
}
map.put(nums[i], i);
}
return null;
}
4.2 数组与内存管理
面试中经常被问到的知识点：
-
数组是对象吗？
- 是的，数组是对象，继承自Object类
- 可以使用arr.length获取长度（不是方法）
-
数组的内存分配
- 基本类型数组：直接存储值
- 对象数组：存储引用
java复制Person[] people = new Person[3]; // 只分配了引用空间
people[0] = new Person(); // 现在才创建实际对象
- 数组的局限性
- 固定长度，扩容需要创建新数组
- 插入/删除元素效率低
- 这些局限催生了ArrayList等集合类
4.3 Java 8中的数组新特性
现代Java提供了更多操作数组的方式：
java复制int[] numbers = {1, 2, 3, 4, 5};
// 使用Stream处理数组
int sum = Arrays.stream(numbers).sum();
int[] evenNumbers = Arrays.stream(numbers)
.filter(n -> n%2 == 0)
.toArray();
// 并行数组排序
int[] largeArray = new int[1000000];
Arrays.parallelSort(largeArray); // 对于大数组更高效
5. 实际项目中的数组应用
5.1 性能优化案例
在开发一个图像处理功能时，我需要处理百万像素级别的数据。最初使用ArrayList，发现内存占用过高。改用二维数组后，性能提升显著：
java复制// 优化前
List<List<Integer>> pixels = new ArrayList<>();
// 优化后
int[][] pixels = new int[height][width];
性能对比：
| 指标 | ArrayList方案 | 数组方案 |
|---|---|---|
| 内存占用 | ~480MB | ~120MB |
| 处理速度 | 1200ms | 450ms |
5.2 数组与JSON的转换
现代Web开发中经常需要处理JSON数组：
java复制// 使用Jackson库
ObjectMapper mapper = new ObjectMapper();
String json = "[1,2,3]";
// JSON转数组
int[] arr = mapper.readValue(json, int[].class);
// 数组转JSON
String jsonOutput = mapper.writeValueAsString(arr);
对于复杂对象数组：
java复制Person[] people = {new Person("Alice"), new Person("Bob")};
String json = mapper.writeValueAsString(people);
// 输出: [{"name":"Alice"},{"name":"Bob"}]
5.3 数组的工具类封装
在实际项目中，我通常会封装一些数组工具方法：
java复制public class ArrayUtils {
/**
* 合并两个数组
*/
public static int[] concat(int[] first, int[] second) {
int[] result = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, result, first.length, second.length);
return result;
}
/**
* 判断数组是否已排序
*/
public static boolean isSorted(int[] array) {
for(int i=0; i<array.length-1; i++) {
if(array[i] > array[i+1]) {
return false;
}
}
return true;
}
}
这些工具方法可以显著提高代码复用率。我在项目中总结的经验是：当某个数组操作被使用超过3次，就应该考虑将其封装成工具方法。