Java数组进阶指南：从青铜到王者的通关秘籍-CSDN博客

本文链接：https://blog.csdn.net/matlab_xiaowang/article/details/147318879

一、数组的"二次觉醒"时刻（重要！）

各位Java萌新们，恭喜你们跨过了数组基础的门槛！但别以为数组就是简单的数据收纳盒（大错特错！）。今天咱们要解锁数组的隐藏技能，让你的代码效率提升300%！先来个灵魂拷问：

为什么用ArrayList时不用手动扩容？（因为底层就是数组啊！）
游戏地图的二维坐标怎么存储？（二维数组申请出战！）
处理表格数据时如何避免"套娃循环"？（多维数组来解围！）

准备好了吗？咱们这就进入数组的进阶世界！（建议准备咖啡，内容硬核但超实用）

二、动态数组的魔法奥秘

2.1 手动实现动态扩容（必学！）

基础数组的致命伤是固定长度，咱们用代码打破这个限制：

// 初始容量5的整型数组
int[] arr = new int[5];
int size = 0;

// 模拟添加元素
public void add(int element) {
    if (size == arr.length) {
        // 扩容1.5倍（行业潜规则）
        int newCapacity = arr.length + (arr.length >> 1);
        arr = Arrays.copyOf(arr, newCapacity);
        System.out.println("触发扩容！新容量：" + newCapacity);
    }
    arr[size++] = element;
}

敲黑板：

>>1 是位运算，相当于除以2（但效率更高！）
1.5倍扩容是性能与空间的平衡点
System.arraycopy() 才是扩容的真·核心方法

2.2 多维数组的降维打击

处理复杂数据结构时，多维数组就是你的瑞士军刀：

2.2.1 二维数组的三种声明方式

// 方式1：声明即初始化
int[][] chessBoard = {
    {1,2,3},
    {4,5,6},
    {7,8,9}
};

// 方式2：先声明后分配空间
double[][] matrix;
matrix = new double[3][4];

// 方式3：锯齿数组（每行长度不同）
String[][] irregularArray = new String[3][];
irregularArray[0] = new String[2];
irregularArray[1] = new String[5];

2.2.2 三维数组实战：魔方模拟

// 创建3x3x3魔方
char[][][] rubiksCube = new char[3][3][3];

// 初始化白色面
for(int i=0; i<3; i++){
    for(int j=0; j<3; j++){
        Arrays.fill(rubiksCube[i][j], 'W');
    }
}

// 打印某一层
public void printLayer(int layer){
    for(char[][] face : rubiksCube){
        System.out.println(Arrays.toString(face[layer]));
    }
}

三、数组操作的"骚操作"合集

3.1 数组排序的六种姿势

Arrays.sort() 快速排序（默认升序）
并行排序：Arrays.parallelSort()
自定义排序（使用Comparator）

倒序排序技巧：

Arrays.sort(arr, Collections.reverseOrder());

部分排序：Arrays.sort(arr, 0, 5)
对象数组排序（实现Comparable接口）

3.2 二分查找的注意事项

使用前提：数组必须已排序！

int[] nums = {1,3,5,7,9};
int index = Arrays.binarySearch(nums, 5);

// 找不到时的返回值规律：
// 返回 -(插入点) - 1
// 比如找6会返回-4（插入点在索引3）

3.3 数组越界的"鬼故事"

经典错误案例：

int[] arr = new int[5];
System.out.println(arr[5]); // 抛出ArrayIndexOutOfBoundsException

避坑指南：

循环时用< length而不是<=
处理用户输入时要校验索引范围
使用增强for循环避免越界

四、实战：学生成绩管理系统

4.1 需求分析

存储多个班级的学生成绩
每个班级人数不同
支持按班级/学科统计
实现成绩查询功能

4.2 核心代码实现

public class GradeManager {
    // 三维数组：年级->班级->学生成绩
    private double[][][] allGrades;
    
    public GradeManager(int gradeNum) {
        allGrades = new double[gradeNum][][];
    }
    
    // 添加班级数据
    public void addClass(int gradeIndex, double[] scores) {
        if(allGrades[gradeIndex] == null) {
            allGrades[gradeIndex] = new double[1][];
        } else {
            allGrades[gradeIndex] = Arrays.copyOf(
                allGrades[gradeIndex], 
                allGrades[gradeIndex].length + 1
            );
        }
        allGrades[gradeIndex][allGrades[gradeIndex].length-1] = scores;
    }
    
    // 统计年级平均分
    public double getGradeAverage(int gradeIndex) {
        double sum = 0;
        int count = 0;
        for(double[][] classes : allGrades[gradeIndex]) {
            for(double[] scores : classes) {
                for(double score : scores) {
                    sum += score;
                    count++;
                }
            }
        }
        return sum / count;
    }
}

五、性能优化黑科技

5.1 内存布局优化

优先使用基本类型数组（int[] vs ArrayList）
对象数组的缓存友好性
避免自动装箱：Integer[]比int[]多消耗4倍内存！

5.2 并行流处理

Arrays.stream(hugeArray)
      .parallel()
      .map(x -> x * 1.5)
      .toArray();

5.3 数组复制的正确姿势

方法	特点	适用场景
System.arraycopy()	最快	底层操作
Arrays.copyOf()	简洁	简单复制
clone()	最方便	快速克隆

六、常见问题排雷指南

6.1 数组 vs 集合怎么选？

需要固定长度/高性能 → 数组
需要动态扩容/丰富API → 集合
内存敏感场景 → 基本类型数组

6.2 多维数组的内存陷阱

二维数组实际是"数组的数组"，每个子数组独立存储。当处理1000x1000的数组时：

int[][] arr = new int[1000][];
for(int i=0; i<arr.length; i++){
    arr[i] = new int[1000]; // 产生1001个对象！
}

优化方案：使用一维数组模拟

int[] smartArr = new int[1000*1000];
// 访问[i][j] → smartArr[i*1000 + j]

七、终极挑战：手写ArrayList

是时候检验学习成果了！试着实现一个简化版ArrayList：

public class MyArrayList<E> {
    private static final int DEFAULT_CAPACITY = 10;
    private Object[] elementData;
    private int size;
    
    public MyArrayList() {
        elementData = new Object[DEFAULT_CAPACITY];
    }
    
    public void add(E e) {
        ensureCapacity(size + 1);
        elementData[size++] = e;
    }
    
    private void ensureCapacity(int minCapacity) {
        if(minCapacity > elementData.length) {
            int newCapacity = elementData.length + (elementData.length >> 1);
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }
    
    @SuppressWarnings("unchecked")
    public E get(int index) {
        rangeCheck(index);
        return (E) elementData[index];
    }
    
    // 其他方法省略...
}