数组是Java语言中最基础、最高效的**数据结构**之一,其本质是**一组类型相同元素的有序集合**,在内存中以**连续空间**形式存储。数组的诞生源于对“批量操作同类型数据”的性能诉求,它摒弃了动态容器的额外开销,直接映射底层硬件寻址机制,因此成为高性能计算场景的首选。
Java数组具有以下**五大核心特性**:
值得注意的是,Java数组虽为对象,但其创建方式不同于普通类——它不通过new关键字调用构造器,而是使用特殊语法(如new int[5]),这种设计既保证了性能,又维持了类型系统的完整性。
Java数组的声明与创建需严格区分两个步骤——**声明**(定义变量类型)与**实例化**(分配内存空间)。错误理解此流程常导致编译或运行时异常。
合法声明格式仅有两种:
int[] scores; // 推荐:类型后接方括号
int scores[]; // 兼容C/C++:类型前接方括号(不推荐)
方括号位置体现设计哲学——前者强调“int类型的数组变量”,后者强调“scores是int数组”,现代Java社区普遍采用第一种写法以提升可读性。
数组创建必须通过new操作符显式分配内存:
scores = new int[5]; // 分配5个int元素,索引范围[0,4]
int[] primes = new int[]{2,3,5,7,11}; // 静态初始化:声明+创建+赋值
若跳过实例化直接使用(如int[] arr; System.out.println(arr[0]);),将抛出编译错误:**“变量arr可能尚未初始化”**。
数组元素在创建时自动赋予类型默认值:
| 元素类型 | 默认值 | 说明 |
|---|---|---|
| 整型(byte/short/int/long) | 0 | 如new int[3] → [0,0,0] |
| 浮点型(float/double) | 0.0 | 如new double[2] → [0.0,0.0] |
| 布尔型(boolean) | false | 如new boolean[1] → [false] |
| 引用类型(对象) | null | 如new String[2] → [null,null] |
此机制确保数组创建后立即可用,但需注意:引用类型数组的元素初始为null,直接调用方法将触发NullPointerException。
初始化方式直接影响代码可读性与健壮性,需根据场景精准选择。
语法格式:类型[] 数组名 = {值1, 值2, ...}
String[] days = {"Mon","Tue","Wed","Thu","Fri"};
double[] temps = {23.5, 24.1, 22.8};
优势:简洁直观,适合元素数量固定且值已知的场景;
注意:不可与new混用(如new double[]{23.5,24.1}合法,但new double[3]{23.5,24.1}非法)。
语法格式:类型[] 数组名 = new 类型[长度]
int[] buffer = new int[100]; // 创建100个零值元素
Student[] classList = new Student[30]; // 创建30个null引用
典型场景:预分配内存以提升后续批量操作效率(如从文件读取数据前预估容量)。
允许先声明动态数组,再部分赋值:
int[] arr = new int[5];
arr[0] = 10; arr[1] = 20; // 其余元素保持默认值0
⚠️ **关键陷阱**:若访问未赋值元素(如arr[2]),虽不报错,但返回默认值0——此行为易引发逻辑错误,需在业务逻辑中显式处理。
数组通过**非负整数索引**访问元素,索引范围为[0, length-1]。
int[] data = {10,20,30};
System.out.println(data[1]); // 输出20
data[2] = 40; // 修改第三个元素
当索引<0或>=length时,JVM抛出ArrayIndexOutOfBoundsException:
i <= arr.length)导致越界,引发服务崩溃。正确写法应为i < arr.length。
在外部库或不确定输入场景中,建议添加边界校验:
public static int safeGet(int[] arr, int index) {
if (index >= 0 && index < arr.length) {
return arr[index];
}
throw new IllegalArgumentException("Index out of bounds: " + index);
}
Java提供多种数组操作方法,需结合场景选择最优方案。
| 方式 | 适用场景 | 性能 | 示例 |
|---|---|---|---|
| for循环(传统索引) | 需修改元素或获取索引 | ★★★★★ | for(int i=0; i |
| 增强for循环 | 只读遍历 | ★★★★☆ | for(int num : arr) { System.out.println(num); } |
| Arrays.stream() | 复杂聚合操作 | ★★★☆☆ | Arrays.stream(arr).sum() |
实测数据:对100万元素数组求和,传统for循环耗时约2.1ms,增强for约2.8ms,Stream约5.3ms——简单操作应优先选择传统循环。
Arrays.sort():使用双轴快速排序(Dual-Pivot Quicksort),平均时间复杂度O(n log n)
int[] nums = {5,1,4,2,8};
Arrays.sort(nums); // 原地排序
Arrays.binarySearch():仅适用于**已排序数组**,返回索引或负插入点
int idx = Arrays.binarySearch(nums, 4); // 返回2
| 方法 | 深度复制? | 性能 | 适用场景 |
|---|---|---|---|
| System.arraycopy() | 浅拷贝 | ★★★★★ | 高性能原生拷贝 |
| Arrays.copyOf() | 浅拷贝 | ★★★★☆ | 改变长度的拷贝 |
| clone() | 浅拷贝 | ★★★☆☆ | 对象数组需谨慎 |
Java多维数组本质是**数组的数组**,非传统数学中的矩阵结构。
int[][] matrix = new int[3][4]; // 3行4列的矩形数组
int[][] jagged = new int[3][]; // 锯齿状数组:每行长度可不同
jagged[0] = new int[2];
jagged[1] = new int[5];
jagged[2] = new int[1];
锯齿数组需分层遍历:
for (int i = 0; i < jagged.length; i++) {
for (int j = 0; j < jagged[i].length; j++) {
System.out.print(jagged[i][j] + " ");
}
System.out.println();
}
int[][] arr = new int[2][3]的内存布局:
两个独立对象:外层数组含2个元素(每个为int[]引用),内层各创建一个长度为3的int数组。
理解数组内存分配对性能调优至关重要。
存储**数组引用变量**(如int[] arr中的arr),占用固定空间(通常4/8字节),生命周期随方法调用结束而销毁。
存储**数组对象实体**,包含:
• 数组长度(length字段)
• 元素数据区(连续内存块)
• 对象头信息(标记、元数据)
数组对象在堆中分配,当无引用指向时由GC回收。大数组(如new byte[1024*1024*100])可能触发Full GC,需注意:
arr = null)| 类型 | 声明示例 | 长度 | 访问结果 |
|---|---|---|---|
| 空数组 | int[] a = new int[0]; | 0 | a.length=0,不抛异常 |
| null数组 | int[] b = null; | 无 | b.length→NullPointerException |
无法在遍历中修改数组结构(如删除元素),且不能获取索引:
for(int x : arr) { if(x>5) arr.remove(x); } → 编译失败(数组无remove方法)对象数组可向上转型,但向下转型需谨慎:
Object[] objArr = new String[3]; // 合法:String[]可转为Object[]
objArr[0] = new Integer(1); // 运行时抛ArrayStoreException!
因JVM在运行时检查元素类型兼容性,确保数组类型安全。
java.util.Arrays提供40+静态方法,核心功能分类如下:
Arrays.equals(arr1, arr2); // 深度比较(逐元素)
Arrays.hashCode(arr); // 基于内容生成哈希值
Arrays.fill(arr, 7); // 全数组填充
Arrays.asList(arr); // 数组→List(注意:返回固定大小列表!)
Arrays.toString(arr); // "[1,2,3]"
Arrays.deepToString(matrix); // 多维数组格式化
Arrays.parallelSort(arr); // 利用多核并行排序
Arrays.parallelPrefix(arr, (a,b)->a+b); // 并行前缀和
数组设计为**内存连续块**,长度可变将导致:
• 扩容时需重新分配大块内存并复制数据(效率低下)
• 可能与其他对象内存区域冲突
• 违背其作为底层数据结构的简洁性原则
解决方案:使用ArrayList等动态容器,其内部通过动态数组实现扩容(默认增长50%)。
选数组场景:
• 已知固定数据量(如一周7天)
• 高频随机访问(如图像像素处理)
• 数值计算密集型(如矩阵运算)
选ArrayList场景:
• 元素数量动态变化
• 需频繁增删中间元素
• 需使用集合框架API(如排序、过滤)
性能对比:对10万次随机访问,数组耗时12ms,ArrayList耗时18ms;对5万次插入,ArrayList耗时280ms,数组需重建(约350ms)。
标准流程:
1. 创建新数组(原长度×1.5+1)
2. 使用System.arraycopy()复制元素
3. 旧数组引用置空
示例代码:
public static int[] grow(int[] arr) {
int newLen = arr.length * 3 / 2 + 1;
int[] newArr = new int[newLen];
System.arraycopy(arr, 0, newArr, 0, arr.length);
return newArr;
}
⚠️ 注意:频繁扩容会导致大量内存复制,建议预估合理初始容量(如ArrayList默认10,HashMap默认16)。
浅拷贝仅复制引用,深拷贝需递归创建新对象:
public static Person[] deepCopy(Person[] original) {
if (original == null) return null;
Person[] copy = new Person[original.length];
for (int i = 0; i < original.length; i++) {
if (original[i] != null) {
copy[i] = new Person(original[i].getName(), original[i].getAge());
}
}
return copy;
}
更优方案:实现Cloneable接口或使用JSON序列化(如Jackson)进行深度克隆。
以int[][] arr = new int[3][4]为例:
• 外层数组对象:16字节(对象头)+ 4字节(length)+ 12字节(3个引用)+ 4字节(对齐填充) = 36字节
• 每个内层数组:16(对象头)+4(length)+16(4个int)+4(填充)= 40字节
• 总计:36 + 3×40 = 156字节
实际占用受JVM实现影响(如CompressedOops开关),但数量级可靠。
数组→List:
String[] arr = {"a","b","c"};
List list = Arrays.asList(arr); // 不可修改长度!
修改list会同步到原数组;添加/删除元素抛UnsupportedOperationException。
List→数组:
String[] arr2 = list.toArray(new String[0]); // 推荐:自动分配合适大小
避免使用toArray(new String[list.size()])——新数组可能更大(当list被并发修改时)。
Dual-Pivot Quicksort为优化平均性能牺牲了稳定性(相等元素相对顺序可能改变)。
稳定替代方案:
• 对象排序:使用Arrays.sort(arr, Comparator.naturalOrder())(内部仍不稳定)
• 强制稳定:改用归并排序实现(需自定义)
• 小数据量:插入排序(稳定且O(n²)在n<47时更快)
基准测试(100万元素数组求和):
• for循环:2.1ms
• 增强for:2.8ms
• Stream:5.3ms
• parallelStream:3.2ms
原因:
• Stream需创建中间对象(Spliterator、Pipeline)
• 小数据量时并行开销大于收益
• JVM优化对传统循环更友好
建议:简单操作用for,复杂聚合用Stream,超大数据集用parallelStream。
空数组:
• 创建方式:new int[0]
• 内存占用:16字节对象头
• 访问length:返回0
• 用途:安全返回值(避免null判断)
null数组:
• 创建方式:int[] arr = null;
• 内存占用:0字节(仅引用变量)
• 访问length:抛NullPointerException
• 用途:表示“无数据”状态(需显式检查)
防御性编程三原则:
1. 循环条件用<而非<=
2. 使用Arrays.copyOfRange()替代手动切片
3. 封装安全访问方法:
public static T safeGet(T[] arr, int index, T defaultValue) {
return (index >= 0 && index < arr.length) ? arr[index] : defaultValue;
}
生产环境建议启用JVM参数-XX:+HeapDumpOnOutOfMemoryError,越界异常是常见内存溢出诱因。