面试过不少候选人也带过不少刚入行的新人我发现在Java基础这一块数组往往是被低估得最严重的那一课。很多人觉得它就是“一种存数据的容器”背几句语法就算会了结果一追问底层布局、初始化细节、拷贝深浅、边界条件立刻就露馅。但你回头看数组恰恰是理解Java内存模型、集合类底层、常见算法的基础设施ArrayList底层是一个Object数组HashMap的哈希桶也离不开数组就连JVM里的堆外结构都和连续内存脱不了干系。这篇东西我想围绕Java数组做一次专项梳理不是简单的语法罗列而是把我这些年里踩过的坑、面试官真正会问的点、刷题时容易忽略的边界情况都串起来。适合正在学Java基础的新人准备校招社招面试的读者以及工作一两年后想回头补地基的朋友。放心内容虽然密但我会尽量讲得直白能跑的例子都给到能解释的原因也绝不跳过。1. 数组的底层本质为什么它是Java的地基1.1 数组也是对象不是基本类型Java只有两种数据类型基本类型int、double、boolean等和引用类型类、接口、数组。数组天然就是引用类型这一点很多人知道但用起来的时候又经常忘记。你写int[] arr new int[5];这里arr是一个引用变量它存在栈上指向堆里真正存放那块连续内存的对象。正因为数组是对象它才有自己的属性length也才可能被null赋值才会出现NullPointerException。面试里有人会把数组当成基本类型说“数组存在栈上”这就是典型的半懂不懂。基本类型数组本身的对象在堆上只是它的元素如果是基本类型那元素的数据是内联存储在一起的不会再有额外的引用跳转。这里有个很有意思的细节int[]的父类是谁直接父类是Object。也就是说你可以写Object obj new int[3];完全合法。这也解释了为什么数组在泛型里会有一堆限制new T[10]编译不通过本质上就是因为泛型类型在运行时会被擦除而数组在运行时必须知道它的具体组件类型。这一点在后面的集合对比里还会再提到。1.2 连续内存与下标从0开始的原因数组之所以能做到 O(1) 的随机访问根源在于它是一块连续的内存空间。只要知道数组起始地址、每个元素占用的大小和下标就能直接算出目标元素的地址。在JVM里数组对象的头部有对象标记、类型指针还有一个记录数组长度的字段真正存储元素的数据区是紧跟着头部连续排列的。访问下标为 i 的元素本质上就是baseAddress i * elementSize这样的偏移计算。下标从0开始是为了省掉一次-1运算。如果从1开始那访问下标为 i 的元素就得是baseAddress (i - 1) * elementSize每次访问都得多做一次减法。在底层高频操作里这种微小的浪费没有意义所以C、C、Java都沿用了从0开始的设计。理解连续内存还有一个实际价值它能解释为什么数组的插入和删除是低效的。在数组中间插入一个元素需要把后续所有元素整体往后挪一位删除同理也要往前挪。这意味着最坏情况下每次操作都是 O(n) 的数据量一上来感觉非常明显。这也就引出了后面要说的集合选型问题。另外数组创建后长度不可变也是因为连续内存一旦分配就没法在原有位置随意扩展扩容只能另开一块更大的空间然后把数据复制过去。2. 创建与初始化最常见却最容易翻车的地方2.1 两种初始化方式与默认值数组初始化分两种静态初始化和动态初始化。静态初始化就是你在写代码的时候直接把元素列出来int[] a {1, 2, 3}; int[] b new int[]{1, 2, 3};这两种写法效果差不多但有个细微差别{1, 2, 3}这种简写只能用在声明变量并赋值的同时如果先声明后赋值就必须写成new int[]{1, 2, 3}。比如int[] a; // a {1, 2, 3}; // 编译错误 a new int[]{1, 2, 3}; // 正确动态初始化则是只指定长度元素由系统赋默认值int[] a new int[3];这时候 a 的内容是[0, 0, 0]。每种类型的默认值不一样这是面试的高频考点也是一个很隐蔽的坑数组类型元素默认值int[]0double[]0.0boolean[]falsechar[]\u0000Object[]包括String[]null引用类型数组默认值是 null这一点特别容易踩。比如你String[] arr new String[3];然后直接arr[0].length()等着你的就是空指针。很多新手写数据读取、对象数组的时候忘记逐个初始化元素一运行就崩根源就在这里。所以动态初始化后引用类型数组的元素往往还要再new出来才能用。2.2 那些看起来对其实是坑的写法第一个坑是length属性。数组的length是属性不是方法。String 的length()是方法这两个别搞混。写循环的时候用arr.length不要写成arr.length()编译直接报错。第二个坑是数组越界。Java的数组越界会抛ArrayIndexOutOfBoundsException而且是在运行时才抛编译期不会提醒你。写遍历时最大的下标是length - 1这个太基础了但我在code review里还是经常看到。有一个比较隐晦的场景循环条件里如果把i arr.length写成小于等于最后一次循环必然越界如果反向遍历用i 0就得小心i--之后变成负数的场景。第三个坑是数组拷贝引用。新手写数组复制最容易写出这样的代码int[] a {1, 2, 3}; int[] b a; b[0] 100; // 此时 a[0] 也变成了 100b a只是把引用复制了一份两个变量指向同一个数组对象。你改b等于改a。这在面试题里出现过很多次叫引用传递的陷阱。想真正复制一份内容需要用后面会讲到的拷贝方法。还有一个易错点是初始化对象数组时的写法Integer[] nums new Integer[3]; nums[0] 1; // nums[1] 是 null如果直接参与拆箱运算会NPEInteger[]是引用类型数组默认全是 null。你用nums[1] 1这种表达式自动拆箱时遇到 null 直接抛空指针。解决办法是逐个初始化或者用Arrays.fill(nums, 0)先填满默认值。3. 遍历与日常操作从打印到拷贝3.1 三种遍历方式和打印技巧数组遍历有三种典型写法。最传统的是普通 for需要下标时用它for (int i 0; i arr.length; i) { System.out.println(arr[i]); }只看值不看下标可以用增强 forfor (int num : arr) { System.out.println(num); }增强 for 写起来简洁但它在底层其实是一个迭代器语法糖。它有两个局限拿不到当前下标不能修改数组里的元素。你以为在增强 for 里给元素重新赋值能改数组内容实际上改变的是局部变量数组原封不动。Java 8 之后数组也可以转成 Stream 来遍历Arrays.stream(arr).forEach(System.out::println);这种方式适合在流的中间环节做过滤、映射后面对比数据时非常方便。不过如果数据量极小直接用 for 反而最直观没必要为了炫技上 Stream。打印数组的坑也值得说。新手直接System.out.println(arr)输出的是[I1b6d3586这种地址信息不是内容。正确做法用Arrays.toString(arr)System.out.println(Arrays.toString(arr)); // [1, 2, 3]那么二维数组怎么办二维数组用Arrays.toString打出来还是一堆地址串必须用Arrays.deepToString。这一点在我带新人时被问过无数次。3.2 数组转集合、转字符串的坑数组转 List 是高频操作几乎每个人都会用Arrays.asList但里面藏了一个大坑。String[] arr {a, b}; ListString list Arrays.asList(arr); list.add(c); // 抛 UnsupportedOperationException为什么因为Arrays.asList返回的是一个基于原数组的固定大小视图不是真正的ArrayList。这个类继承自AbstractListadd、remove 方法没有实现调用就直接抛异常。所以如果你想要一个可以增删元素的列表需要这样包装一层ListString list new ArrayList(Arrays.asList(arr));另一个容易被忽略的问题Arrays.asList对原始类型数组的表现和预期完全不同。你Arrays.asList(intArray)传一个int[]得到的 List 的泛型参数是int[]而不是 Integer。换句话说你会得到一个包含一个数组元素的 List遍历它得到的不是每个数字而是整个数组对象。要正确转换基本类型数组通常需要循环或借助 Stream 的Arrays.stream(arr).boxed().collect(Collectors.toList())。数组转字符串也有很多姿势。Arrays.toString是最省事的但它的输出带方括号和逗号比如[1, 2, 3]。如果想去掉括号拼成自定义格式循环拼接是最直白的StringBuilder sb new StringBuilder(); for (int i 0; i arr.length; i) { if (i 0) sb.append(,); sb.append(arr[i]); } // 输出 1,2,3字符串转字符数组则是str.toCharArray()按某个分隔符分割用str.split(,)。注意split返回的是一个新数组如果你只想要第一个元素先判空再取下标不然空字符串调用split会返回包含一个空字符串的数组。3.3 数组拷贝与扩容的正确姿势数组拷贝有三种常见方式循环复制、System.arraycopy、Arrays.copyOf。最原始的是手写循环最容易理解但性能不是最优。System.arraycopy是 native 方法底层直接操作内存性能最好。它的签名比较啰嗦System.arraycopy(src, srcPos, dest, destPos, length);比如int[] src {1, 2, 3, 4, 5}; int[] dest new int[5]; System.arraycopy(src, 0, dest, 0, src.length);Arrays.copyOf是System.arraycopy的封装更简洁还支持指定新长度天然就是扩容的姿势int[] arr {1, 2, 3}; int[] newArr Arrays.copyOf(arr, 10);复制所有元素到一个新长度10的数组多余位置补0。ArrayList 扩容底层用的就是Arrays.copyOf这个思路。如果你是自己封装动态数组推荐直接用Arrays.copyOf省去手写循环出错的可能。还有一个常见需求是数组的clone()。int[] copy arr.clone();对一维基本类型数组是深拷贝改copy不影响原数组。但如果是二维数组或者对象数组clone()默认是浅拷贝只复制了外层引用内层数组或对象还是同一份。这个在热词里对应了Java对象深度拷贝后面我会在二维数组部分展开讲。4. 经典算法现场复现排序、查找、去重与反转4.1 冒泡排序两层循环与两次优化冒泡排序是面试、笔试里出现频率最高的排序题因为它简单、直观适合考察基本功。思路就是相邻元素两两比较大的往后冒。public static void bubbleSort(int[] arr) { 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]) { swap(arr, j, j 1); } } } }第一层循环控制轮数最多n - 1轮第二层循环控制每轮比较范围因为每轮结束最大的数已经沉到底部所以范围可以减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]) { swap(arr, j, j 1); swapped true; } } if (!swapped) break; }加了标志位之后面对一个接近有序的大数组性能会好很多。面试时能主动说出这两种优化思路比默写基本版要加分不少。4.2 二分查找用溢出安全的写法二分查找的前提是数组有序。基础的写法很多但有一个细节值得专门提出来中间位置的计算。很多老教材写(left right) / 2这个写法在极端情况下可能溢出。当 left 和 right 都接近Integer.MAX_VALUE时两者相加会溢出成负数结果直接出错。正确且推荐的做法有两种int mid left (right - left) / 2; // 或者 int mid (left right) 1;第二种用无符号右移left right溢出的高位会被丢弃结果依然正确。这个知识点在面试中属于懂底层的细节能说出来会显得基本功扎实。二分查找的完整实现还要处理边界条件找不到时要返回什么Arrays.binarySearch返回的是负的插入点减1如果查找不到返回值-insertionPoint - 1这个约定面试时也常被问到。4.3 数组去重从双重循环到原地去重数组去重是实际业务里经常遇到的场景面试官也会让你手写。最朴素的方法是双重循环每个元素跟后面所有元素比对遇到重复就跳过。时间复杂度 O(n^2)数据量一上来就不太行了。如果题目允许额外空间用 HashSet 是最快的public static int[] removeDuplicates(int[] arr) { SetInteger set new LinkedHashSet(); for (int num : arr) { set.add(num); } int[] result new int[set.size()]; int i 0; for (int num : set) { result[i] num; } return result; }LinkedHashSet能保持插入顺序而HashSet不保证顺序。如果对顺序有要求用 LinkedHashSet。还有一类经典的变形题给定一个已经排序的数组要求原地去重并返回新长度不允许使用额外空间。这是LeetCode 26题的思路核心是用一个慢指针维护不重复区域的位置public static int removeDuplicatesInPlace(int[] nums) { if (nums.length 0) return 0; int slow 0; for (int fast 1; fast nums.length; fast) { if (nums[fast] ! nums[slow]) { slow; nums[slow] nums[fast]; } } return slow 1; }这类题考查的是对指针位置和覆盖顺序的理解慢指针指向最后一位不重复元素快指针负责探路。4.4 三个数组最大乘积把边界条件想全这个题目是从热搜词里看到的我觉得很有意思因为它特别能考察边界条件是否想全。题目是给一个整数数组求三个数的最大乘积。很多人的第一反应是取三个最大的数相乘但这样会漏掉一种情况如果数组里有负数两个极小的负数相乘会得到一个很大的正数再乘上最大的正数结果可能比三个最大正数的乘积还大。所以正确解法是先排序然后比较两种组合Arrays.sort(nums); int n nums.length; int case1 nums[n - 1] * nums[n - 2] * nums[n - 3]; // 三个最大正数 int case2 nums[0] * nums[1] * nums[n - 1]; // 两个最小负数相乘乘以最大正数 return Math.max(case1, case2);这个题给我们的启示是数组题不能只盯着正向思维负数和零的存在会让边界情况变得刁钻。4.5 数组分割与包含某字符的匹配热搜词里有个数组分割并显示包含某一字符的需求这在日常业务里很常见比如从一个文件路径数组里筛出所有包含2024的路径。如果是在字符串数组里过滤用循环加contains最直观String[] paths {/data/2024/report, /data/2023/report, /data/2024/summary}; ListString result new ArrayList(); for (String path : paths) { if (path.contains(2024)) { result.add(path); } }Java 8 之后可以用 Stream 一行解决String[] result Arrays.stream(paths) .filter(s - s.contains(2024)) .toArray(String[]::new);这里toArray(String[]::new)的写法是生成指定类型数组的标准姿势等于是给自己留了个自定义数组生成器的入口。如果想把过滤结果继续拼接、分组都建议在这个流式处理的基础上扩展。5. 二维数组与不规则数组别在内存模型上栽跟头5.1 数组的数组Java二维数组的真实结构Java没有真正的多维数组二维数组本质上是数组的数组。你写int[][] arr new int[3][4];外层的 arr 是一个长度为3的数组其中每个元素都是指向一个长度为4的一维 int 数组的引用。这意味着两点。第一arr.length得到的是行数arr[0].length得到的是列数。如果每一行长度不一样你写代码时就必须单独处理。第二外层引用数组和每一行的一维数组在堆内存中是各自独立的对象内存地址并不连续所以不能把Java的二维数组想象成一块整整齐齐的矩形内存块它更像一个引用数组挂在外面数据数组挂在里面的结构。C里的多维数组是真正连续的内存块所以才会出现热词里c 多维数组 指针的说法——C里拿一个指针加上偏移量就能遍历整块数据。Java没有指针二维数组的访问只能靠两层下标这是语言差异也是不少人从C转过来时不适应的点。5.2 不规则数组与深拷贝不规则数组是Java二维数组的灵活之处。你可以先只指定行数再逐行指定列数int[][] triangle new int[5][]; for (int i 0; i triangle.length; i) { triangle[i] new int[i 1]; }这样就能构建一个杨辉三角形结构。但也要小心在这种写法下如果某一行还没有初始化triangle[i]是 null直接访问triangle[i][0]会抛空指针。遍历前必须先判空。二维数组的拷贝也是重灾区。直接int[][] copy original.clone();只复制了外层引用数组内层的每个一维数组对象还是共享的。你改copy[0][0]原数组的[0][0]也会变。这就是所谓的浅拷贝。要真正深拷贝一个二维数组需要手动遍历每一行对每个一维数组单独复制int[][] original {{1, 2}, {3, 4, 5}}; int[][] copy new int[original.length][]; for (int i 0; i original.length; i) { copy[i] Arrays.copyOf(original[i], original[i].length); }如果数组里放的是可变对象那还需要更深一层对每个对象也做拷贝。这是Java对象深拷贝的完整链条二维数组深拷贝只是其中一个环节。写工具类时很多人图省事直接调clone结果埋下共享引用的隐患这种问题在并发场景下排查起来非常折磨人。6. 动态数组与集合的取舍数组之外怎么选6.1 手写一个动态数组理解扩容机制数组长度固定这是硬伤。实际开发中往往是动态数据量这时候就要用到动态数组。ArrayList 就是官方提供的动态数组但为了真正理解它我建议你自己动手实现一个简化版。核心结构就是三个成员一个 Object 数组、一个 size 计数器、一个默认容量常量。public class SimpleDynamicArray { private Object[] data; private int size; public SimpleDynamicArray() { data new Object[10]; size 0; } public void add(Object element) { if (size data.length) { grow(); } data[size] element; } private void grow() { int newCapacity data.length (data.length 1); data Arrays.copyOf(data, newCapacity); } public Object get(int index) { if (index 0 || index size) { throw new IndexOutOfBoundsException(Index: index); } return data[index]; } public int size() { return size; } }注意grow这个方法里的扩容策略data.length (data.length 1)这正好是原长度加一半也就是1.5倍。ArrayList 实际扩容就是这个策略不是常见的翻倍。为什么选1.5倍而不是2倍这是空间和时间之间的折中扩容倍数越大搬运元素次数越少但预留的闲置空间越多倍数越小空间利用率高但扩容搬运频繁。1.5倍是一种经过权衡的选择。另一个细节是data数组用的是Object[]而不是泛型数组。因为前面说过泛型在运行时类型信息会被擦除你没法直接创建T[]。等到取元素时再做强转这是实际动态数组的实现套路。面试时如果问到为什么ArrayList底层用Object[]而不是T[]答案就藏在这里。6.2 ArrayList与数组面试官想听什么数组和 ArrayList 的区别是面试高频题回答得好不好取决于你有没有真正理解它们各自的定位。两者至少有四个层面的区别。第一数组长度固定创建后不能变ArrayList 自动扩容长度动态变化。第二数组可以存储基本类型也可以存储引用类型ArrayList 只能存引用类型存 int 要用Integer的包装类直接new ArrayListint()编译报错。第三数组访问是直接下标操作没有额外校验ArrayList 的get方法里会有索引校验越界抛IndexOutOfBoundsException。第四数组性能更好尤其是在高频随机访问场景下少了方法调用和越界检查的开销ArrayList 因为内部就是对数组的封装绝大多数操作和数组一样但多了一层间接性。还有一层更深入的区别数组在创建时就可以和泛型协同而 ArrayList 这类泛型类自身没法直接实例化泛型数组这源于Java泛型的运行时擦除机制。面试官如果追问到这里你说出数组是协变的泛型是不变的这句话基本就能过关了。实际选型建议是数据量确定且不变、对性能敏感、需要存基本类型直接用数组数据量不确定、需要频繁增删用 ArrayList。如果业务高度依赖随机访问但几乎不增删两者性能差异已经很微小优先选可读性更好的 ArrayList。写算法题的时候能用数组就用数组因为算法题要求的是极致的边界控制和性能数组足够直白。7. 面试经典题与避坑清单7.1 三组高频面试追问第一组是length、length()和size()有什么区别。数组的length是属性String 的length()是方法集合的size()是方法。三者的使用对象完全不同答这题时要顺手把数组、String、集合三者的数据组织方式说清楚。第二组是数组和 ArrayList 如何互相转换。数组转集合记住Arrays.asList返回的固定大小视图不能add/remove真想要可变的要包一层new ArrayList。集合转数组用list.toArray()得到Object[]要指定类型用list.toArray(new String[0])。注意传一个长度为0的新数组是官方推荐写法JVM会根据列表大小重新分配合适长度不用提前猜测容量。第三组是为什么数组是协变的。这是泛型相关的进阶题。数组的协变指的是String[]可以被赋给Object[]因为 String 是 Object 的子类。这种设计让数组在运行时会检查具体类型所以Object[] objArr new String[3]; objArr[0] 1;会在运行时抛ArrayStoreException。而泛型是不变的ListString不能赋给ListObject这避免了运行时类型安全问题。这两套机制的不同解释了为什么泛型数组的创建那么别扭。7.2 已知固定数值找出数组中的组合热搜词里有一句已知固定数值如何确定数组中的哪些数据和等于固定值这就是典型的子集和问题也是面试里回溯算法的入门题。比如给定数组[2, 3, 5, 7]和目标和7需要找出所有能加起来等于7的组合[2, 5]和[7]。最通用的解法是递归回溯。每一层决定当前这个数选还是不选选进去就继续往下探索和刚好等于目标时记录结果public static ListListInteger findCombinations(int[] nums, int target) { ListListInteger result new ArrayList(); Arrays.sort(nums); backtrack(nums, target, 0, new ArrayList(), result); return result; } private static void backtrack(int[] nums, int remain, int start, ListInteger path, ListListInteger result) { if (remain 0) { result.add(new ArrayList(path)); return; } for (int i start; i nums.length; i) { if (nums[i] remain) break; if (i start nums[i] nums[i - 1]) continue; // 跳过重复 path.add(nums[i]); backtrack(nums, remain - nums[i], i 1, path, result); path.remove(path.size() - 1); } }这段代码里有三个关键点。第一先排序这样一旦当前数已经大于剩余值可以直接break剪枝省时间。第二i 1表示每个数只能用一次如果你希望同一个数能重复使用就改成i而不是i 1。第三i start nums[i] nums[i - 1]用来跳过重复元素避免产生重复组合。这类题看起来是数组题本质是搜索和剪枝但数组提供了最直接的载体。7.3 实战避坑速查清单我整理了一份数组相关的常见问题速查表都是实际编码里高频踩中的点场景常见坑正确做法打印数组直接 println(arr) 输出地址用 Arrays.toString(arr)二维数组打印用 toString 输出地址串用 Arrays.deepToString(arr)数组复制直接赋值引用修改互相影响用 System.arraycopy 或 Arrays.copyOf二维数组复制clone 只复制外层引用逐行 copyOf 实现深拷贝数组转 List直接 add/remove 抛异常new ArrayList(Arrays.asList(arr))基本类型数组转 List得到的是含整组数组的 List用 Stream 逐个装箱初始化对象数组元素默认 null直接使用抛NPE逐个 new 或 Arrays.fillforEach 里修改元素修改的是局部变量数组没变用普通 for 下标赋值循环删除集合元素用 for 循环容易漏元素或抛并发异常用迭代器或 removeIf最后再补充一个实操建议刷题的时候凡是数组题先把边界条件写在注释里比如数组为空只有一个元素全是负数有重复值。把这些情况在代码里都跑一遍你会发现很多隐藏问题提前暴露而不是等面试官追问时才慌。数组题目练得够多你对循环边界的敏感度会明显提升这对后面学链表、树这些结构都有好处。