数组是Java中存储多个同类型数据的基础方式，通过索引访问元素，支持声明、初始化、遍历、查找、排序和复制等操作，但需注意数组大小固定、索引越界、空指针及引用传递等常见问题。
Java中要存储多个同类型的数据，最基础也最直接的方式就是使用数组。它就像一个整齐排列的盒子，每个格子都能放一个相同类型的东西，并且你总能通过格子的编号（索引）找到或放入你需要的数据。这对于处理批量信息，比如一堆数字、一系列名字，简直是再合适不过了。
解决方案
在Java里，数组的声明和初始化有几种常见的方式，每种都有它的应用场景。
首先，你可以先声明一个数组变量，然后再给它分配内存空间。比如，声明一个可以存放整数的数组：
int[] numbers; // 声明一个名为numbers的整型数组变量 numbers = new int[5]; // 为这个数组分配5个整型数据的空间
这里需要注意，
new int[5]
意味着数组里会有5个格子，索引从0开始，到4结束。当你这样分配空间后，每个格子都会被自动初始化为该类型的默认值（比如int是0，Boolean是false，对象类型是NULL）。
立即学习“Java免费学习笔记（深入）”；
如果你在声明时就已经知道要存哪些数据，可以直接初始化：
String[] names = {"张三", "李四", "王五"}; // 声明并初始化一个字符串数组 double[] prices = new double[]{19.99, 29.50, 10.00}; // 另一种初始化方式，效果相同
访问数组中的数据非常简单，就是通过索引：
System.out.println(names[0]); // 输出 "张三" numbers[2] = 100; // 把第三个位置（索引为2）的值修改为100 System.out.println(numbers[2]); // 输出 100
要知道数组有多少个元素，可以用它的
属性：
System.out.println(names.length); // 输出 3
遍历数组通常用循环，这是数组最常用的操作之一：
// 使用for循环遍历 for (int i = 0; i < names.length; i++) { System.out.println("名字是：" + names[i]); } // 使用增强for循环（foreach），更简洁，但不能获取索引 for (String name : names) { System.out.println("另一个名字是：" + name); }
为什么我们需要数组，而不是单独的变量？
我个人觉得，当你需要处理的数据量一旦超过三五个，或者说这些数据在逻辑上是紧密关联的一组时，单独的变量就显得非常笨拙了。想象一下，如果你要存储一个班级50个学生的成绩，难道你要定义
score1
,
score2
,
score3
…一直到
score50
吗？这不仅写起来麻烦，管理起来更是噩梦。
数组的出现，正是为了解决这种“批量管理”的需求。它把所有同类型的数据都打包在一起，用一个统一的名字（数组名）来指代，然后通过简单的索引就能访问到任何一个具体的数据。这大大简化了代码，也让数据的组织结构变得清晰明了。更重要的是，有了数组，我们就可以利用循环结构，非常高效地对所有数据进行统一的操作，比如计算总分、查找最高分等等。没有数组，这些操作简直不可想象，代码会变得又臭又长，维护起来也异常困难。所以，在我看来，数组是程序处理“集合”概念的基石，它让数据变得可迭代、可管理。
数组的常见操作有哪些，以及它们背后的逻辑？
数组的操作远不止声明和访问那么简单，它还有很多实用的技巧，而这些技巧背后，其实都蕴含着一些基本的编程思想。
遍历： 这是最基本也是最频繁的操作。我们前面提到了
for
循环和增强
for
循环。
for
循环之所以强大，是因为它能让你精确控制到每一个元素的索引，这在需要根据位置进行操作（比如隔一个元素处理一次）或者需要同时修改元素值时非常有用。而增强
for
循环则更侧重于“迭代”，它只关心数组里有什么元素，而不关心它们具体在哪，所以代码会更简洁，适合只读访问。
查找： 最直接的查找方式就是“线性查找”。从数组的第一个元素开始，一个接一个地比对，直到找到目标或者遍历完整个数组。这背后的逻辑就是简单的条件判断和循环。虽然对于大型数组效率不高，但它是理解查找算法的起点。
int[] numbers = {10, 20, 30, 40, 50}; int target = 30; boolean found = false; for (int i = 0; i < numbers.length; i++) { if (numbers[i] == target) { System.out.println("找到了目标值 " + target + " 在索引 " + i); found = true; break; // 找到后就可以停止了 } } if (!found) { System.out.println("没有找到目标值 " + target); }
排序： 让数组中的元素按照某种顺序（升序或降序）排列。Java标准库提供了
方法，它底层使用了高效的排序算法（如Quicksort或MergeSort的变体），我们不需要关心具体的实现细节，直接调用即可。这大大简化了我们的工作，但理解排序的目的是让数据更有序、更易于查找（比如二分查找的前提就是有序）。
import java.util.Arrays; // 记得导入这个包 int[] unsortedNumbers = {5, 2, 8, 1, 9}; Arrays.sort(unsortedNumbers); // 升序排序 System.out.println("排序后的数组：" + Arrays.toString(unsortedNumbers)); // 输出 [1, 2, 5, 8, 9]
复制： 当你需要一个数组的副本时，直接把一个数组变量赋值给另一个，并不会复制数组的内容，它们会指向同一个内存地址。要真正复制内容，你需要创建一个新数组，然后把旧数组的元素一个个复制过去，或者使用Java提供的方法，比如
System.arraycopy()
或
Arrays.copyOf()
。这背后的逻辑是理解“引用类型”和“值类型”的区别，数组是引用类型，变量存储的是内存地址。
int[] original = {1, 2, 3}; int[] copy = Arrays.copyOf(original, original.length); // 复制所有元素 original[0] = 100; System.out.println("原始数组：" + Arrays.toString(original)); // [100, 2, 3] System.out.println("复制数组：" + Arrays.toString(copy)); // [1, 2, 3]
数组使用中常见的“坑”和新手误区？
在使用数组时，有些问题是新手特别容易踩到的“坑”，理解它们能帮助你少走很多弯路。
1.
ArrayIndexOutOfBoundsException
： 这是数组操作中最常见的错误之一。它发生在当你尝试访问一个超出数组合法索引范围的元素时。记住，Java数组的索引总是从0开始，到
length - 1
结束。比如一个长度为5的数组，它的合法索引是0, 1, 2, 3, 4。如果你尝试访问
array[5]
或
array[-1]
，就会抛出这个异常。这通常是循环条件写错，或者索引计算有误导致的“差一错误”。
int[] arr = new int[3]; // arr[3] = 10; // 错误！会抛出ArrayIndexOutOfBoundsException for (int i = 0; i <= arr.length; i++) { // 错误！i <= arr.length会导致最后一次访问arr[3] // System.out.println(arr[i]); }
2. 数组的固定大小： Java中的数组一旦创建，它的大小就是固定的，不能改变。如果你需要一个更大的数组，你不能简单地“扩展”它。你必须创建一个全新的、更大（或更小）的数组，然后把旧数组中的元素复制到新数组中。这个特性对于初学者来说可能有点反直觉，因为在其他一些语言中数组是可以动态伸缩的。理解这一点非常重要，它会引出后续对
ArrayList
等动态集合的学习。
3. 对象数组中的
NullPointerException
： 如果你创建了一个存储对象的数组（比如
String[]
或自定义类的数组），除非你明确地为每个位置赋值，否则数组的每个元素默认都是
null
。当你尝试调用一个
null
元素的任何方法时，就会遇到
NullPointerException
。
String[] words = new String[2]; // 此时 words[0] 和 words[1] 都是 null // System.out.println(words[0].length()); // 错误！会抛出NullPointerException words[0] = "hello"; System.out.println(words[0].length()); // 正确，输出 5
4. 引用传递的陷阱： 数组是引用类型。这意味着当你把一个数组变量赋值给另一个数组变量时，它们实际上指向的是内存中的同一个数组对象。所以，通过其中任何一个变量对数组内容的修改，都会反映在另一个变量上。这和基本数据类型的赋值行为是完全不同的。如果你想要一个独立的副本，必须进行显式复制。这是理解Java内存管理和对象引用的一个关键点。
int[] a = {1, 2, 3}; int[] b = a; // b和a现在指向同一个数组 b[0] = 99; System.out.println(a[0]); // 输出 99，因为a和b是同一个数组
这些“坑”往往是理解数组底层工作原理的关键点。掌握了它们，你在Java数组操作的路上就能走得更稳健。
