1. 数组是什么：先抛开教科书定义
1.1 数组的本质：一块连续的内存容器
很多同学在学Java的第一周就会碰见数组，但绝大多数人只是把它当成"一种存多个变量的东西"。这个理解不能说错，但太浅了。如果只看表面，你根本想不明白为什么数组的索引是0开始、为什么数组一旦创建长度就不能变、为什么把数组传给方法之后方法里改元素外面也跟着变。
数组的本质，是一块连续的内存空间。什么叫连续？就是你在堆内存里申请了n个格子，这n个格子的地址是紧挨着的。因为紧挨着，所以计算某个元素的位置只需要做一次加法：首地址 + 索引 * 每个元素占用的字节数。这也是为什么数组访问任意一个元素的时间复杂度是O(1)——它不需要从头遍历去找，直接按地址偏移就算出来了。
你可以把数组想象成一排编号的储物柜。柜子从0号开始编号，每个柜子大小一样，相邻柜子之间没有缝隙。你只要知道第一个柜子的位置，就能通过编号快速算出任意柜子的位置。这就是数组的底层逻辑。
Java里的数组和C语言有点不一样：C语言里数组名可以退化成指针，Java里数组就是一个对象。这一点后面会重点讲，因为它牵涉到内存布局、方法传参、空指针等一系列你迟早要踩的坑。
1.2 为什么说数组是"最基础"的数据结构
很多人在学完ArrayList之后就开始嫌弃数组，觉得数组功能少、不够灵活。但你必须明白，ArrayList的底层就是数组。你去看源码，里面有Object[] elementData，所有增删改查都是对这个数组的操作。HashMap在扩容时也依赖数组的拷贝。可以说，如果你不懂数组，你其实也没法真正理解这些所谓的高级容器。
数组的"缺点"其实也是它的特点：长度固定、元素类型固定。正是因为固定，它的内存布局才能做到连续，连续才能做到随机访问最快。当你面对"长度已知、不会频繁增删"的数据集合时，数组就是最高效的选择。
我在实际开发里见过的场景包括：固定数量的配置项、按星期索引的排班表、矩阵运算、缓存池的核心存储引擎。这些场景用数组比用集合更合适——省内存、无装箱开销、访问极快。
2. 定义一个数组的完整姿势：声明、创建、初始化一条龙
2.1 声明与创建的区别：你的代码到底干了什么
先看最常见的写法：
int[] nums; // 声明 nums = new int[5]; // 创建第一行只做了一件事：在栈上声明一个引用变量nums，它此刻没有指向任何对象，值为null。第二行才是在堆内存中真正开出一块能放5个int的连续空间，并把这块空间的首地址赋值给nums。
我见过很多初学者搞混这两步，甚至有人以为int[] nums;就已经分配了内存。你可以自己验证一下：只写声明不创建，然后访问nums.length，编译器会报错（局部变量未初始化），或者运行时报NullPointerException。这就是因为引用变量根本没有指向堆对象。
也可以一步写完：
int[] nums = new int[5];这行代码的含义是：先声明，再创建，然后赋值。用创建对象的眼光来看，new int[5]就是一次对象实例化，只是它的类型是数组类型而已。
还有一种奇怪但合法的写法：
int nums[] = new int[5];方括号放在变量名后面，这是从C语言带过来的风格。Java语法允许这么写，但强烈不建议——int[] nums才符合"这是一个int数组类型的变量"的语义。
2.2 静态初始化与动态初始化的使用场景
静态初始化就是在创建时直接指定内容：
int[] primes = {2, 3, 5, 7, 11}; String[] names = {"张三", "李四", "王五"};动态初始化则是先指定长度，再逐个赋值：
int[] scores = new int[5]; scores[0] = 90; scores[1] = 85;什么时候用哪种？我的判断标准很简单：如果数据在写代码时就已经确定了，用静态初始化；如果数据需要运行时从外部读入、计算出来，用动态初始化。比如你要做一个星期排班表，一周七天固定，直接String[] days = {"周一", ...}。比如你要根据用户输入的数量创建数组，那只能new int[n]。
另一个细节：静态初始化语法int[] a = {1,2,3}其实是简写，它等价于int[] a = new int[]{1,2,3}。但如果你把声明和创建拆开，就不能用简写：
int[] a; a = {1, 2, 3}; // 编译错误 a = new int[]{1, 2, 3}; // 正确因为这个语法糖只允许在声明时连写。
2.3 数组的默认值：不要被"没有赋值"骗了
动态创建数组之后，不是里面什么都没有，而是每个元素都被赋予了该类型的默认值。规则如下：
| 数组元素类型 | 默认值 |
|---|---|
| byte / short / int / long | 0 |
| float / double | 0.0 |
| char | '\u0000'（空白字符） |
| boolean | false |
| 引用类型（String、对象等） | null |
这里最容易踩的坑是引用类型数组。比如：
String[] arr = new String[3]; System.out.println(arr[0].length()); // 空指针你以为数组创建好了，每个元素就可以用了，但引用类型数组的元素默认值是null，你必须逐个初始化才能调用它们的方法。这个坑在项目里写DTO数组、对象数组时经常遇到，排查起来还挺隐蔽。
3. 内存原理拆解：数组在JVM里到底怎么放
3.1 栈、堆、方法区：数组元素住哪里
JVM运行时数据区里，和数组关系最密切的是栈（Stack）和堆（Heap）。局部变量、方法参数这些引用存在栈帧里；真正的对象实体（包括数组元素）存在堆里。
来看这段代码：
public void demo() { int[] a = new int[3]; a[0] = 10; a[1] = 20; }执行流程是这样的：
- 方法
demo()被调用时，JVM为它在栈上分配一个栈帧。 - 栈帧里的局部变量表有
a这个槽位，初始为null。 - 执行
new int[3]时，JVM在堆中分配一块连续内存，大小能容纳3个int，并把这块内存的首地址压栈，赋给变量a。 a[0] = 10会顺着a保存的地址去堆内存找偏移量为0的位置，写入10。
这里最关键的概念是：栈上保存的是引用，堆里保存的是数据。数组变量本身不是数组，它只是握住数组的一根绳子。
3.2 引用变量的"绳子"与堆内存的"气球"
我特别喜欢用一个类比：数组变量是绳子，堆里的数组对象是气球。绳子可以绑到新的气球上，也可以剪断（赋值为null），甚至可以多条绳子绑同一个气球（数组引用赋值）。
当你写出这样的代码：
int[] a = new int[3]; int[] b = a;b和a指向的是同一个数组对象，不是拷贝。你改b[0]，a[0]也会变。这就是引用的含义。
这个特性导致的常见错误就是误以为赋值是拷贝。我见过有人这样写代码：
int[] original = {1, 2, 3}; int[] backup = original; backup[0] = 99; // original[0]也变成99了真正的拷贝必须用循环、System.arraycopy或Arrays.copyOf，后面会详细说。
还有一个内存细节：数组对象在堆里的结构，除了元素数据之外，还有一个对象头（mark word + 类型指针）和length字段。所以数组对象占用的内存是"对象头 + length + 元素数据 + 对齐填充"。不同JVM实现细节有差异，但只要记住数组本身是对象就够了。
3.3 length是属性还是方法？数组对象的结构
很多从C语言转过来的人会下意识写arr.length()，结果发现编译不过。这不是因为你没加括号，而是因为数组的length是一个属性（field），不是方法。String的length()是方法，数组的length是属性。一个是arr.length()，一个是arr.length，别混了。
为什么数组的length是属性？因为数组对象在创建时，length就被写进了对象头旁边的一个字段里，并且被final标记（实际上数组的length是final的，你不能修改它）。所以访问arr.length就是直接读取这个字段，没有任何方法调用开销。这也是数组随机访问性能好的一个因素。
3.4 空指针异常的根源：引用没有指向对象
数组相关的NullPointerException，八成是这两种场景：
int[] a = null; System.out.println(a.length); // NPE String[] b = new String[5]; System.out.println(b[0].length()); // 元素是null，调用方法NPE理解内存原理后，这两个NPE的根源是同一个：试图通过一个不指向任何堆对象的引用去访问堆内存。a本身是null；b[0]是null。这两种情况都相当于"绳子没有绑气球，却去拽气球里的东西"。
排查数组NPE时，我通常先打印数组本身，再看是"数组引用为null"还是"元素为null"，这两种修复方式完全不同。前者是没new，后者是没给元素赋值。
4. 数组操作实战：遍历、拷贝、反转与查找
4.1 三种遍历方式与增强for的适用边界
普通for循环：
for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); }增强for（for-each）：
for (int num : arr) { System.out.println(num); }Java对数组遍历还提供了Stream方式：
Arrays.stream(arr).forEach(System.out::println);从性能上说，普通for和增强for对于数组几乎没有差别，因为增强for编译后底层就是普通for加索引遍历。但有一个重要区别：增强for拿不到索引。如果你需要知道当前元素的下标，就只能用普通for。另外，增强for里不能修改数组元素——注意，是"不能通过增强for修改"，因为循环变量是元素的拷贝（基本类型）或引用的拷贝（引用类型）。比如：
int[] arr = {1, 2, 3}; for (int num : arr) { num = 100; // 没用，arr不变 }对于引用类型数组，增强for拿到的是引用拷贝，你修改对象内部的属性是可以生效的，但给循环变量重新赋值不会影响数组。这个细节很多人分不清。
4.2 System.arraycopy与Arrays.copyOf的差异
数组拷贝有四种常见方式：
- 手写for循环
System.arraycopyArrays.copyOfclone()
其中System.arraycopy是一个native方法，性能最高，而且支持拷贝一段连续区间的元素：
int[] src = {1, 2, 3, 4, 5}; int[] dest = new int[5]; System.arraycopy(src, 1, dest, 0, 3); // dest变成{2, 3, 4, 0, 0}参数含义分别是：源数组、源起始位置、目标数组、目标起始位置、拷贝长度。这个方法要求源和目标都不能是null，且区间不能越界。
Arrays.copyOf是JDK提供的便捷方法：
int[] copy = Arrays.copyOf(src, src.length);它内部其实也是调用了System.arraycopy，但多了一步：先new一个长度为newLength的新数组，再把源数组的内容拷过去。所以Arrays.copyOf更适合"先创建新数组再整体拷贝"的场景，它甚至可以扩长：
int[] bigger = Arrays.copyOf(src, 10); // 多余的位置填0clone()也能拷贝，但它是Object的方法，返回Object，需要强转，而且对于一维数组是深拷贝（拷贝元素值），对于多维数组是浅拷贝（只拷贝第一层引用）。一般不太推荐直接用clone。
4.3 数组反转的两种实现思路
反转一个数组，思路有两个：
思路一：新建一个数组，倒着放：
public static int[] reverseNew(int[] arr) { int[] result = new int[arr.length]; for (int i = 0; i < arr.length; i++) { result[i] = arr[arr.length - 1 - i]; } return result; }思路二：原地交换，双指针：
public static void reverseInPlace(int[] arr) { int left = 0, right = arr.length - 1; while (left < right) { int temp = arr[left]; arr[left] = arr[right]; arr[right] = temp; left++; right--; } }注意思路二不能写left <= right，因为当数组长度是奇数时，中间的元素不需要交换；长度是偶数时，最后一次交换后left会大于right。写<=在数组长度为奇数时会多做一次自交换，结果虽然一样，但属于多余操作。
实际开发里，面试官很喜欢问这个问题。你最好能说出两种方案的取舍：思路一不修改原数组、额外O(n)空间；思路二原地修改、O(1)空间。如果你不想影响原数据，选思路一；如果只是临时要反转后使用，原地反转更省内存。
4.4 线性查找与二分查找的实用场景
在数组中找一个元素，最直接的办法是线性查找：
public static int linearSearch(int[] arr, int target) { for (int i = 0; i < arr.length; i++) { if (arr[i] == target) { return i; } } return -1; }时间复杂度O(n)，适合无序数组。如果数组是有序的，应该用二分查找，时间复杂度O(log n)。Java里可以直接用Arrays.binarySearch，但有个必须注意的坑：它要求数组必须有序，否则结果是不确定的。
int[] arr = {1, 3, 5, 7, 9}; int index = Arrays.binarySearch(arr, 5); // 返回2如果找不到，返回的是-(插入点) - 1。比如查找4，插入点应该是2（因为4应该插在索引2那个位置，即5的前面），返回值是-2-1=-3。这个负数的含义很多人搞不懂，体检起来就出bug。如果你只关心元素是否存在，判断>=0即可。
二分查找的手写实现，我建议你至少自己敲一遍。别看Arrays.binarySearch方便，手写能帮你真正理解为什么有序是前提。
5. 多维数组：数组的数组，不要想复杂
5.1 二维数组的内存布局（行指针？）
Java里的二维数组，本质上是一维数组的数组。也就是说：
int[][] matrix = new int[3][4];这行代码先创建了一个长度为3的一维数组，这个数组的每个元素又是一个长度为4的int数组。也就是说，matrix本身是一个长度为3的数组，里面存的是三个指向int数组的引用。
内存布局上，matrix[0]、matrix[1]、matrix[2]分别指向三个独立的内存空间。这三个空间不一定连续！虽然大多数人对二维数组的直觉是"一个表格"，但它在内存里其实是"三个独立的row，通过一个行索引数组串起来"。
这一点对性能影响重大：如果你循环访问二维数组，尽量按行遍历，也就是先固定i再遍历j。因为每一行内部是连续的，按行遍历可以充分利用CPU缓存；按列遍历会频繁跳内存地址，性能差很多。我做矩阵运算时实测过，同样规模的数据，按行遍历比按列遍历快数倍。
5.2 不规则数组与Arrays.fill的坑
Java的二维数组不必是规则的。你可以这样定义：
int[][] arr = new int[3][]; arr[0] = new int[2]; arr[1] = new int[5]; arr[2] = new int[1];这就叫不规则数组（ragged array）。某些场景下很省内存，比如三角形矩阵。
这里有个经典坑：Arrays.fill对二维数组不能直接填满所有元素。Arrays.fill(matrix, 0)实际上是把matrix的每个元素（即行引用）替换成0，也就是把matrix[i]指向null，大错特错。正确做法是逐行填充：
for (int i = 0; i < matrix.length; i++) { Arrays.fill(matrix[i], 0); }还有，Java没有真正的"多维数组传参"语法，如果你想把二维数组传给一个方法，直接传引用即可，在方法里修改会影响原数组。
6. 数组与工具类：Arrays的常用方法与隐藏坑
6.1 toString、sort、binarySearch的使用细节
直接打印数组，输出的是类似[I@1b6d3586这样的字符串。[I表示int数组，@后面是哈希地址。所以想看到内容必须用Arrays.toString：
int[] arr = {3, 1, 4, 1, 5}; System.out.println(Arrays.toString(arr)); // [3, 1, 4, 1, 5]如果是二维数组，要用Arrays.deepToString，否则打印出的还是每一行的地址。
Arrays.sort默认按自然顺序升序排列，底层用的是双轴快速排序（对基本类型）和TimSort（对引用类型）。如果你想降序，基本类型数组不能直接传Comparator，需要转成包装类型：
Integer[] arr = {3, 1, 4}; Arrays.sort(arr, Collections.reverseOrder());为什么基本类型不能？因为Comparator是针对对象的，基本类型需要装箱。如果你非要原地降序排int[]，就先升序然后反转，或者自己写一个排序函数。
顺便说一句：Arrays.sort对部分有序的数组表现极好，因为它会先检查数组是否接近有序。这是JDK的优化，知道这个特性就够了。
6.2 数组转List的三种姿势与坑
最常见的是Arrays.asList：
String[] arr = {"a", "b", "c"}; List<String> list = Arrays.asList(arr);这个list有几个限制：它返回的是一个固定长度的List，不能add和remove。你一旦调用list.add("d")，会抛UnsupportedOperationException。因为Arrays.asList底层还是那个数组，只是套了个List的壳。另外，如果你修改原数组，这个list也会变，因为它是直接引用原数组的视图。
还有个大坑：Arrays.asList对基本类型数组的表现让人意外：
int[] nums = {1, 2, 3}; List<int[]> list = Arrays.asList(nums); // 不是List<Integer>，而是List<int[]>，里面只有一个元素因为泛型不能是基本类型，int[]被当成了一个整体对象。你如果写List<int[]> list，长度是1不是3。正确做法是用Arrays.stream(nums).boxed().collect(Collectors.toList())，或者用ArrayList的构造器配合循环。
第二种姿势是直接new ArrayList<>(Arrays.asList(arr))，这样得到的才是真正的可变ArrayList，可以增删。
第三种姿势是Java 9+的List.of(arr)，但它返回的也是不可变List，不能增删，而且不允许null元素。选哪种取决于你是否需要后续修改列表。
6.3 数组拷贝的深浅问题
一维数组的拷贝，只要用System.arraycopy或Arrays.copyOf，拷贝的是元素值。如果元素是基本类型，那就是完全深拷贝；如果元素是引用类型，其实只是把引用拷过来，两个数组里的对象还是同一个。举个例子：
String[] arr1 = {"hello", "world"}; String[] arr2 = Arrays.copyOf(arr1, arr1.length); arr2[0] = "hi"; // arr1[0]不变因为String是不可变的，所以看起来没问题。但如果数组里放的是可变对象：
StringBuilder[] arr1 = {new StringBuilder("a")}; StringBuilder[] arr2 = Arrays.copyOf(arr1, arr1.length); arr2[0].append("b"); // arr1[0]也是"ab"原因：拷贝的是对象的引用，不是对象本身。这就是浅拷贝。如果你要深拷贝，需要对每个元素单独克隆或新建对象。二维数组更是如此：int[][] copy = original.clone()得到的只是浅拷贝，子数组依然是引用共享。想要完整深拷贝二维数组，必须嵌套循环逐行拷贝。
这个深浅拷贝问题在实际开发中极其常见，尤其是做数据快照、缓存副本时，如果没注意，会改到不该改的数据。
7. 避坑总结：这些错误我在项目里真的见过
7.1 索引越界：ArrayIndexOutOfBoundsException
这个异常太常见了。常见写法：
int[] arr = new int[5]; for (int i = 0; i <= arr.length; i++) { // i <= 导致越界 arr[i] = i; }问题是边界条件多写了一个等号。索引合法范围是0 ~ length-1，访问arr[length]必炸。
另一个隐蔽场景是数组扩容时的拷贝越界。比如你手写一个动态数组，插入时忘了判断容量，直接data[size] = value，size增长到data.length后就越界。此类问题最佳实践是：凡是遍历数组，一律用i < arr.length，不要写<=；凡是涉及下标计算，先验上下界。
7.2 "数组是对象"带来的NPE
数组是对象，但很多人没有真正意识到。把数组当参数传给方法时，如果方法内部没有对null做校验，就可能炸。我见过一段业务代码，从数据库查出一批记录，用toArray转成数组，然后直接访问[0]，结果一次性查不到数据就NPE。正确做法是先判断数组长度：
if (arr == null || arr.length == 0) { // 处理空数组 }另外，数组的元素默认值那节提到的引用类型数组元素为null，也是NPE高发区。尤其是对象数组例如User[] users = new User[10]，你只给users[0]赋值，其他全是null，然后循环遍历调用user.getName()就炸了。
7.3 可变参数与数组的关系
Java的可变参数（varargs）本质上就是数组。你看方法签名：
public void print(String... args)调用时你可以传多个String，也可以直接传一个String[]。但有个坑：如果你同时有print(String[] arr)和print(String... args)两个重载，调用print(null)会编译报错，因为编译器不知道选哪个。这种重载要避免。
还有，可变参数必须放在参数列表的最后，而且最多只能有一个可变参数。如果你把String... args写在前头，编译直接报错。这个细节在做工具类封装时经常碰到。
7.4 数组与泛型的纠缠
数组和泛型不能很好地合作。你不能写：
T[] arr = new T[5]; // 编译错误因为泛型在运行时会被擦除，JVM无法确知具体组件类型来创建该类型的数组。实际开发里常见的变通做法是：
public class MyStack<T> { private T[] data; @SuppressWarnings("unchecked") public MyStack(int capacity) { data = (T[]) new Object[capacity]; } }这里强转会有unchecked警告，因为运行时data的真实类型是Object[]，只是你在编译期通过强转让它看起来是T[]。如果你在调用方不小心把data向下转型为String[]，就会抛ClassCastException。所以很多集合类（比如ArrayList）内部其实是Object[]，对外用泛型做转换，而不是真的创建泛型数组。
还有一个相关坑：协变与逆变。数组是协变的，意思是String[]是Object[]的子类型，所以你可以把String[]赋值给Object[]变量。但集合（如List<String>）不是List<Object>的子类型，赋值会编译报错。这个差异会导致你在泛型场景下误以为数组和集合行为一致，结果踩坑。总之，涉及泛型和数组混合的场景，优先用集合，实在要用数组就在封装类里藏着，别对外暴露原始数组。
最后分享一个我自己的习惯：写完数组相关代码，我一定会做三件事——检查所有下标是否在0~length-1范围内；检查所有引用类型元素是否可能为null；检查数组拷贝是深还是浅。这三件事做完，数组相关的运行时错误基本能杜绝一大半。
如果你刚开始学Java，别急着追求各种高深框架，把数组这块硬骨头啃透，后面的集合、IO、并发里遇到"连续内存""索引计算""深浅拷贝"这些概念时，你会发现自己理解得特别快。
