java数组 〔深度站〕

Java数组 · 完全知识体系

从数组声明、初始化、遍历到多维数组、性能优化与常见陷阱,一站掌握所有核心。

⚡ 为什么数组是基石?

Java数组是存储固定大小同类型元素的容器。它在内存中连续分配,提供O(1)随机访问能力。几乎所有高级数据结构(如ArrayList、HashMap)底层都依赖数组。掌握数组意味着理解Java内存模型与性能调优的第一步。

〔★〕 网民最常搜的数组问题

  • 数组如何初始化?默认值是什么?
  • 数组与ArrayList性能对比?
  • 如何高效拷贝数组?
  • 多维数组内存布局?
  • Arrays.sort()原理?

【优化】数组性能关键点

缓存局部性、避免越界、预分配大小、使用System.arraycopy()、避免在循环中创建新数组。合理使用数组能提升30%以上执行效率。

〖一〗 数组声明、初始化与内存

⑴ 声明方式

int[] arr; 或 int arr[]; 推荐前者。声明并不创建数组,只是引用。

int[] numbers; // 推荐
int numbers[]; // C风格,不推荐
String[] names = new String[5]; // 创建5个元素的数组

⑵ 初始化与默认值

数组创建后,元素自动初始化为默认值:数字类型为0,boolean为false,引用类型为null。

int[] a = new int[3]; // [0,0,0]
boolean[] b = new boolean[2]; // [false,false]
String[] s = {"A", "B"}; // 静态初始化

⑶ 内存布局与length

数组在堆内存中连续存储。 arr.length 是数组的唯一属性,表示容量。 length 不是方法,注意与String的length()区分。

例如: int[] arr = new int[10]; arr.length 值为10。

〖二〗 多维数组 & 拷贝 & 排序

◇ 多维数组本质

Java多维数组是数组的数组。例如 int[][] matrix = new int[3][4]; 创建了3个长度为4的一维数组。内存中不一定是连续矩形,每行可以不同长度(锯齿数组)。

int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[4];
jagged[2] = new int[1];

遍历多维数组使用嵌套循环,注意行索引和列索引。 for-each 同样适用。

  • 三维数组: int[][][] cube = new int[2][3][4];
  • 常用场景:矩阵运算、图像处理、游戏地图。

◇ 数组拷贝的四种方式

  1. System.arraycopy() —— 原生方法,最快,推荐。
  2. Arrays.copyOf() —— 内部调用arraycopy,可扩容。
  3. clone() —— 浅拷贝,一维数组可用。
  4. for循环 —— 手动复制,灵活性高但慢。
int[] src = {1,2,3,4,5};
int[] dest = new int[5];
System.arraycopy(src, 0, dest, 0, src.length); // 最佳实践
int[] copy = Arrays.copyOf(src, 10); // 扩容,多余元素默认0

注意: 二维数组clone()是浅拷贝,仅复制第一层引用。

◇ Arrays.sort() 与 binarySearch

Arrays.sort() 使用双轴快速排序(基本类型)或TimSort(对象类型),时间复杂度O(n log n)。

int[] arr = {5, 3, 1, 4, 2};
Arrays.sort(arr); // [1,2,3,4,5]
int index = Arrays.binarySearch(arr, 3); // 返回2

使用binarySearch前必须排序。自定义对象需实现Comparable或传入Comparator。

  • 并行排序: Arrays.parallelSort() 利用多核。
  • 部分排序: Arrays.sort(arr, fromIndex, toIndex)

〖三〗 高频热点 · 深度解答

① 数组与ArrayList性能差异?

数组 固定长度,随机访问极快,无额外开销。 ArrayList 动态扩容,每次扩容需要拷贝数组(耗时)。频繁增删用ArrayList,追求极致性能且大小固定用数组。 实测: 百万级循环中数组比ArrayList快约20-30%。

② 数组越界异常原因?

访问索引小于0或大于等于length时抛出 ArrayIndexOutOfBoundsException。常见于循环条件误用 <= length 或减一错误。预防:使用 for-each 或 Arrays 工具类。

③ 如何将数组转换为List?

使用 Arrays.asList() 返回固定大小列表,不支持增删。若需可变列表: new ArrayList<>(Arrays.asList(arr))。注意基本类型数组需用包装类型。

④ int[] 与 Integer[] 区别?

int[] 存储基本类型,内存连续,效率高。 Integer[] 存储对象引用,每个元素是Integer对象,占用更多内存,但可与泛型协作。 性能差距: 基本数组快3-5倍。

⑤ 数组扩容的最佳实践?

使用 Arrays.copyOf() 或 System.arraycopy()。避免手动循环。扩容因子通常1.5倍(类似ArrayList策略)。

〖五〗 实用示例与代码片段

◇ 原地反转数组

使用双指针法,时间复杂度O(n),空间O(1)。

public static void reverse(int[] arr) {
   int left = 0, right = arr.length - 1;
   while (left < right) {
     int temp = arr[left];
     arr[left++] = arr[right];
     arr[right--] = temp;
   }
}

示例:输入 [1,2,3,4,5] → 输出 [5,4,3,2,1]。

◇ 移除指定值(非原地)

返回新数组,不破坏原数组。使用流或手动拷贝。

public static int[] removeElement(int[] arr, int val) {
   return Arrays.stream(arr).filter(x -> x != val).toArray();
}

或者使用ArrayList辅助。注意:基本类型数组需用IntStream。

◇ 合并两个有序数组

类似归并排序的merge操作,双指针从后往前可避免额外空间。

public static int[] merge(int[] a, int[] b) {
   int[] res = new int[a.length + b.length];
   int i=0, j=0, k=0;
   while (i < a.length && j < b.length) {
     res[k++] = (a[i] <= b[j]) ? a[i++] : b[j++];
   }
   while (i < a.length) res[k++] = a[i++];
   while (j < b.length) res[k++] = b[j++];
   return res;
}

◇ 最大子数组和(Kadane算法)

经典动态规划,O(n)时间。

public static int maxSubArray(int[] nums) {
   int maxSoFar = nums[0], maxEndingHere = nums[0];
   for (int i=1; i<nums.length; i++) {
     maxEndingHere = Math.max(nums[i], maxEndingHere + nums[i]);
     maxSoFar = Math.max(maxSoFar, maxEndingHere);
   }
   return maxSoFar;
}

示例:[-2,1,-3,4,-1,2,1,-5,4] → 最大子数组 [4,-1,2,1] 和为6。

以上示例展示了数组的常见操作,实际开发中可灵活组合。 记住: 数组是性能与简洁的完美平衡点。