企业官网建设流程全解析

在头歌这个实训平台上刷Java题目，“数组"那一关从基础走到进阶，相信不少同学都有过这样的体验：单选题看哪个选项都像对的，编程题脑子里有思路，一写代码就是各种越界、空指针，最气人的是明明本机运行好好的，一提交就是一堆红色的测试用例不通过。这篇博文就拿"数组进阶"系列实训题当靶子，把数组相关的核心操作、常见算法和那些容易踩坑的细节一次讲透。

适合正在学Java、准备头歌实训考试或者做课程作业的同学参考，也适合那些数组用得不深、想一次性补牢基础的人。文章不会绕弯子，直接拆题、拆知识点、拆代码，把这些题目背后真正想考的东西摊开看。

1. 数组进阶到底在考什么——先把题目套路看穿

头歌的"数组进阶"不是一个单独的题，而是一组连续的小任务，通常涉及数组定义、遍历、排序、查找、复制、二维数组这些内容。很多同学觉得难，不是因为某一个知识点多深，而是没有把这些题目当成一个体系去看。

1.1 基础操作是底线，别让简单题丢分

数组进阶系列的第一批题目，表面上是在考"你会不会用数组"，实际上是在抠细节。比如数组的长度一旦确定就不能变，这决定了后续所有操作的基础；比如数组下标从0开始，遍历的终止条件写成<= arr.length就是越界；再比如数组是引用类型，直接赋值给另一个变量，其实共享的是同一块内存。

这些点看起来简单，但头歌的测试用例是会故意设计边界条件的。我见过太多人栽在"空数组""只有一个元素的数组""全是相同元素"这三种极端情况上。进阶阶段的基本功，就是能在这些边界条件下写出不崩溃、结果正确的代码。

1.2 进阶技能点：排序、查找、复制、多维遍历

过了基础以后，题目会开始要求你实现一些"指定方法"。常见的有这么几类：

• 冒泡排序、选择排序的手写实现
• 二分查找在有序数组中的定位
• 数组之间复制、拼接、截取
• 二维数组的按行遍历、按列遍历

这些内容不是凭空来的，它们在后续的Java学习中会反复出现。比如排序算法直接关系到学习Arrays.sort()时能不能理解为什么底层要换排序策略；二分查找是后续学习二叉树、搜索算法时的思维起点；二维数组更是后面做矩阵运算、存储表格数据、甚至图像处理的基础。

一句话总结：头歌的"数组进阶"在知识上不超纲，但非常考验代码正确性和逻辑严谨性。这也是很多同学觉得"明明都学过，但就是写不对"的根本原因。

2. 多维数组的建立与遍历——从书写语法到内存布局

数组进阶题目里，二维数组是一个分水岭。一部分同学在这里第一次感受到"数组里面套数组"这种结构，另一部分同学则要开始理解Java中多维数组其实不是数学意义上的矩阵，而是一维数组的数组。

2.1 二维数组的声明和初始化，先搞清楚三种写法

二维数组的初始化方式有几种，很多人只记得其中一种，考试时稍一变形式就懵了。

第一种是静态初始化，直接在声明时把数据写死：

int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

第二种是动态初始化，先规定行数和列数，然后再逐位赋值。这里有个高频考点：int[][] arr = new int[3][4];表示3行4列，共12个元素，默认值全部是0。

第三种是非规则二维数组，也就是每行的列数可以不一样。这在头歌的进阶题里经常出现，比如下面的写法是合法的：

int[][] triangle = new int[5][]; for (int i = 0; i < triangle.length; i++) { triangle[i] = new int[i + 1]; }

这段代码创建了一个"金字塔"形状的数组，第0行1个元素，第1行2个元素，以此类推。Java允许这种写法，是因为二维数组本质上是一个保存了多个一维数组引用的数组。这一点不理解的话，后面做矩阵变换、螺旋矩阵这类题目就会很痛苦。

2.2 遍历二维数组的两种思路，测试用例喜欢考什么

遍历二维数组有按行遍历和按列遍历两种基本方式。按行遍历就是外层循环控制行、内层循环控制列，这个大家都熟。按列遍历则要反过来，外层循环控制列、内层循环控制行。

头歌的题目会在遍历的基础上叠加其他操作，比如求主对角线元素之和、求每行的最大值、将矩阵转置。这些题目的核心都不在数学，而在循环下标的控制。

求主对角线元素有个很漂亮的规律：当i == j时，matrix[i][j]就在主对角线上。所以只要一轮循环就能搞定：

int sum = 0; for (int i = 0; i < matrix.length; i++) { sum += matrix[i][i]; }

矩阵转置的思路则是遍历上三角区域，交换matrix[i][j]和matrix[j][i]：

for (int i = 0; i < matrix.length; i++) { for (int j = i + 1; j < matrix[i].length; j++) { int temp = matrix[i][j]; matrix[i][j] = matrix[j][i]; matrix[j][i] = temp; } }

注意内层循环是从i + 1开始的，不是从0开始。从0开始会导致同一对元素被交换两次，等于原地绕了一圈，矩阵没变。

提示：遇到二维数组的题目，先画一个3行3列的表格，手工走一遍循环，搞清楚下标变化再写代码。我见过太多人逻辑图清晰、代码写得一团糟，结果就错在一两个下标上。

3. 排序与查找：算法背后的原理和代码实现

数组进阶一定会涉及排序和查找，这是面试之外最常被问到的数组操作。头歌的题目一般不会让你直接调用工具方法，而是要你手写算法，原因是想让你理解过程，而不是背结论。

3.1 冒泡排序的优化：为什么交换次数可以少一半

冒泡排序的基本思想是相邻元素两两比较，大的往后挪。外层循环控制总共需要比较的轮数，内层循环负责真正执行相邻比较。

基础版是这样的：

for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } }

注意内层的arr.length - 1 - i，很多人会忘记减 i。其实道理很简单：经过 i 轮排序后，最大的 i 个元素已经沉到了数组末尾，它们不需要再参与比较，所以比较范围可以逐步缩小。

进阶题目可能会让你进一步优化，比如记录本轮是否发生过交换，如果没有交换说明数组已经有序，提前结束：

for (int i = 0; i < arr.length - 1; i++) { boolean swapped = false; for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; swapped = true; } } if (!swapped) { break; } }

这个优化在应对"几乎有序"的数组时效果特别明显，测试用例也喜欢准备这种数据来考验代码的鲁棒性。

3.2 二分查找：有序数组的快速定位

二分查找的基础是数组必须有序。它的核心是每次把搜索范围缩小一半：维护左边界low和右边界high，取中间位置mid，比较中间元素和目标值的大小，然后决定在左半部分还是右半部分继续查找。

标准写法如下：

public static int binarySearch(int[] arr, int target) { int low = 0; int high = arr.length - 1; while (low <= high) { int mid = low + (high - low) / 2; if (arr[mid] == target) { return mid; } else if (arr[mid] < target) { low = mid + 1; } else { high = mid - 1; } } return -1; }

有两个细节值得注意。第一，mid写成low + (high - low) / 2而不是(low + high) / 2，前者可以避免两个很大的整数相加时溢出。这在笔试中可能不考，但确实是个好习惯。第二，while的条件是low <= high，不是low < high。如果写错，在搜索区间只剩一个元素时会漏查。

3.3 一个综合案例：合并两个有序数组

排序和查找经常组合出现，比如给你两个已经有序的数组合并成一个有序数组，要求不使用工具方法、不额外开辟空间（在原数组上操作），这是一个典型进阶题。

从后往前填充是最优雅的做法：

public static void merge(int[] nums1, int m, int[] nums2, int n) { int i = m - 1; int j = n - 1; int k = m + n - 1; while (i >= 0 && j >= 0) { if (nums1[i] > nums2[j]) { nums1[k--] = nums1[i--]; } else { nums1[k--] = nums2[j--]; } } while (j >= 0) { nums1[k--] = nums2[j--]; } }

从后往前遍历能避免覆盖原来的有效元素，因为nums1的后半部分是空置的。这个思路在头歌的数组进阶题里出现过不止一次，记下来很值。

4. Arrays工具类：生产环境里更常用的数组玩法

如果只在头歌平台上做题，手写排序和查找就够了；但如果将来要写真正的小项目，几乎所有人都会选择直接使用java.util.Arrays工具类。这是标准库给开发者准备的百宝箱，里面封装了大量数组操作。

4.1 sort与binarySearch：排序和查找的官方实现

Arrays.sort()是对数组进行排序。对于基本类型数组，它底层使用快速排序的变种（比如双轴快速排序）；对于对象类型数组，它使用稳定的归并排序变种。你不需要记住具体实现，但要知道：对基本类型数组，排序是不稳定的；对对象数组，排序是稳定的。这个特性在部分场景下会有影响。

Arrays.binarySearch()要求在调用前数组必须已经有序，否则结果不可靠。它返回的是目标值在数组中的下标。如果没找到，它不返回-1，而是返回-(插入点) - 1，这个规则很多人不知道。例如：

int[] arr = {1, 3, 5, 7, 9}; int idx = Arrays.binarySearch(arr, 6); // 返回值为 -4，表示 6 应该插在下标3的位置

因为数组中没有6，正确的插入点是下标3，所以返回值是-(3) - 1 = -4。知道这一点后，如果想把新元素插入有序数组且保持有序，可以借助这个公式反推插入点。

4.2 copyOf与equals：数组复制和比较的隐藏细节

Arrays.copyOf()用来复制数组，它比手动写循环要可靠得多，而且支持指定长度，复制出来的数组长度不足时用默认值补齐。

int[] original = {1, 2, 3}; int[] copy = Arrays.copyOf(original, 5); // copy 的内容是 {1, 2, 3, 0, 0}

如果长度小于原数组长度，则只截取前几个元素。

Arrays.equals()用来比较两个数组内容是否完全相同。注意，数组之间用==比较的是引用，只有两个变量指向同一块内存时才为 true，而Arrays.equals逐个比较元素值。对于二维数组，则要使用Arrays.deepEquals()。

这些工具方法在头歌的数组进阶编程题里未必是标准答案，但如果你把它们当作"捷径"用在允许的题目里，效率会高很多。当然，前提是你能判断测试用例是否会因为调用工具类而判定超时或违规——一般实训题对此没有限制。

5. 对象数组与综合实战：从数组到面向对象思维的过渡

数组进阶系列里有一类题容易让人当场卡壳：对象数组。比如定义一个"学生类"，然后创建一个学生数组，按某个属性排序，或者查找某个条件的学生。这类题目把数组和面向对象缝合在了一起，考察的是更高一层的综合能力。

5.1 对象数组的声明与创建，先别急着赋值

对象数组的定义格式是类名[] 数组名 = new 类名[长度];。这一步只是创建了一个"可以存放对象引用的数组"，每个位置的默认值都是null，并没有真的创建对象。

所以接下来必须逐个给数组元素赋值：

Student[] students = new Student[3]; students[0] = new Student("张三", 90); students[1] = new Student("李四", 75); students[2] = new Student("王五", 88);

少了赋值这一步，后面访问students[0].getScore()时就会抛出空指针异常。这也是头歌这类题目最常见的报错来源。

5.2 按对象属性排序：用冒泡排序思想处理对象数组

按某个属性排序，本质和排序基本类型数组一样，区别只是比较的对象不再是数字，而是对象中的字段。比如按成绩从高到低排序：

for (int i = 0; i < students.length - 1; i++) { for (int j = 0; j < students.length - 1 - i; j++) { if (students[j].getScore() < students[j + 1].getScore()) { Student temp = students[j]; students[j] = students[j + 1]; students[j + 1] = temp; } } }

交换的是整个对象引用，不是把分数单独拿出来换。这一点一定要想清楚，否则就会出现"名字没换，分数换了"这种诡异结果。

在进阶的综合题里，这类需求经常包装成"统计最高分的学生信息""查找指定名字的学生""计算班级平均分"等任务。解题的思路都很直接：遍历数组，在遍历过程中维护一个变量记录当前的最值或累加和，最后输出结果。真正的难点不是算法，而是对对象数组元素为 null 的边界判断。

6. 那些年我踩过的坑——数组进阶常见问题排查实录

如果你现在正在头歌平台被测试用例折磨，下面的内容值得多看几遍。这些是我见过最多的问题，基本上覆盖了"代码逻辑对但通不过测试"的大部分情况。

6.1 索引越界：循环条件的边界问题

这是最常见的报错，ArrayIndexOutOfBoundsException一出现，首先检查所有for循环的终止条件。一个统一的排查技巧：如果数组长度是n，能访问的下标范围是0到n - 1。凡是出现<=的场景都要当作可疑对象。

// 错误示范：会访问 arr[n]，越界 for (int i = 0; i <= arr.length; i++) { System.out.println(arr[i]); } // 正确写法 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); }

6.2 空指针：数组元素没有初始化

对象数组默认值是null，基本类型数组默认值是0。如果定义了Integer[]或者String[]，先用先判空。处理对象数组时我习惯在遍历前写一个非空校验，尤其是题目要求查找某个对象时：

if (students[i] != null && students[i].getName().equals(targetName)) { // 找到目标 }

6.3 复制数组时改了一个，另一个跟着变了

数组是引用类型，直接用int[] b = a;不会复制内容，只是让b和a指向同一块内存。需要通过Arrays.copyOf或循环赋值才能实现真正的复制。这个知识点在进阶题里经常以"修改副本不应影响原数组"的形式出现。

6.4 判断数组相等，别只看返回值对不对

两个数组内容相同但引用不同，用==比较结果永远是false。要比较内容应该使用Arrays.equals。如果测试用例反复失败，检查一下代码里有没有==比较数组的地方。

6.5 二分查找前忘了排序

这是一个逻辑陷阱，不是语法错误。没有排序的数组直接binarySearch，结果不会报错，但必然不稳定。遇到"查找结果错误"的评测反馈时，先确认调用二分查找之前，数组确实已经排好序了。

最后说点实在的：数组进阶这一组题，本质上是在逼你养成"动手前先画图、写完代码先测边界"的习惯。我自己的经验是，每次拿到题目，先在草稿纸上写好数组下标的变化过程，再动键盘。别看这一步简单，它帮我省掉的排错时间远超过写代码时间。如果在头歌平台上被卡的次数多了，说明你的问题不是不会写某一句代码，而是对整个数组操作流程缺少大局观。把上面这些细节逐个消化掉，再回去刷题，你会明显感觉到同一道题变简单了。