一、一维数组基础
 
1. 核心概念
 
数组是用于批量存储相同类型数据的容器，可实现批量数据的统一管理与操作，是Java最基础的数据结构。
 
2. 完整使用步骤
 
1. 声明数组：定义数组存储类型与名称，推荐格式： 数据类型[] 数组名; 

2. 分配内存：指定数组长度，为数组开辟连续内存空间： 数组名 = new 数据类型[长度]; 

3. 元素操作：通过下标完成存取，下标从 0 开始，合法范围： 0 ~ 数组长度-1 

- 存元素： 数组名[下标] = 数值; 

- 取元素： 数组名[下标] 

4. 遍历数组：利用循环依次访问所有元素，获取数组长度： 数组名.length 
 
异常提醒：下标超出合法范围，运行抛出  ArrayIndexOutOfBoundsException （数组下标越界异常）
 
3. 数组默认初始化值
 
数组创建后，系统会自动为元素赋默认值，规则如下：
 
- 基本整数类型： 0 

- 浮点类型： 0.0 

- 布尔类型： false 

- 字符类型：空字符

- 引用/对象类型： null 
 
4. 三种初始化方式
 
1. 先声明后分配： int[] arr; arr = new int[5]; 

2. 声明同时初始化： int[] arr = new int[]{1,2,3,4}; 

3. 简写静态初始化： int[] arr = {1,2,3}; 
 
注意：简写方式必须声明和赋值同时完成，不可拆分。

二、数组内存原理（难点）
 
1. Java中数组在堆内存分配连续的存储空间，引用变量存储在栈内存。

2. 数组变量存储的是堆内存中数组的首地址，并非数组本身。

3. 寻址逻辑： 首地址 + 下标 × 单个元素占用字节数 ，下标从0开始，可提升寻址效率。

4. 赋值区别：

- 基本类型赋值：传递具体数值，互不影响；

- 数组（引用类型）赋值：传递内存地址，多个变量指向同一数组，修改会互相影响。

三、数组扩容实现
 
Java数组长度固定不可直接修改，扩容本质是：新建更长数组 → 复制旧元素 → 引用指向新数组，常规新数组长度为原数组2倍。
 
1. 手动循环扩容

int[] oldArr = {1,7,4,3};
// 1. 创建长度为原数组2倍的新数组
int[] newArr = new int[oldArr.length * 2];
// 2. 循环复制元素
for(int i = 0; i < oldArr.length; i++){
    newArr[i] = oldArr[i];
}
// 3. 原数组引用指向新数组
oldArr = newArr;

2. 系统方法复制扩容
 
1.  System.arraycopy(原数组, 原起始下标, 新数组, 新起始下标, 复制长度) ：底层原生方法，效率高

2.  Arrays.copyOf(原数组, 新长度) ：自动创建新数组+完成复制，一行代码实现扩容

int[] arr = {1,6,8,3};
int[] newArr = Arrays.copyOf(arr, arr.length*2);
arr = newArr;

四、可变长参数
 
1. 概念
 
JDK5.0新增特性，用于定义接收任意个数同类型参数的方法，底层本质是数组。

2. 语法与规则

// 格式：数据类型... 参数名
public static void test(int... nums){
    // nums 自动转为int[]数组，可直接遍历使用
    for(int i : nums){
        System.out.println(i);
    }
}

- 一个方法最多只能有1个可变参数；

- 可变参数必须放在形参列表最后一位；

- 可接收0个、1个或多个同类型实参，提升代码通用性。

五、数组排序
 
1. 冒泡排序（基础手写）
 
核心逻辑：相邻元素两两比较，逆序则交换，每轮将最大值“冒泡”到末尾。

// 从小到大排序
for(int i = 1; i < arr.length; i++){
    for(int j = 0; j < arr.length - i; j++){
        if(arr[j] > arr[j+1]){
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

2. 选择排序
 
核心逻辑：固定当前下标，遍历后续所有元素，找到最小值交换到当前位置。

for(int i = 0; i < arr.length-1; i++){
    for(int j = i+1; j < arr.length; j++){
        if(arr[i] > arr[j]){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}

3. 工具类快速排序
 
 java.util.Arrays.sort(数组名) ，底层为优化后的快速排序，开发中直接使用。

六、二维数组
 
1. 概念
 
二维数组本质是存储一维数组的一维数组，可看作多行多列的表格，分为规则二维数组和不规则二维数组。
 
2. 基础语法
 
1. 声明： 数据类型[][] 数组名; 

2. 分配空间： int[][] arr = new int[行数][列数]; 

3. 元素访问： 数组名[行下标][列下标] ，行、列下标均从0开始

4. 长度获取：

-  arr.length ：获取行数

-  arr[i].length ：获取第i行的列数
 
3. 初始化方式
 
1. 动态初始化： int[][] arr = new int[3][4]; （3行4列）

2. 静态初始化： int[][] arr = {{1,2},{3,4,5},{6}}; 
 
4. 不规则二维数组
 每行元素个数不相等，语法要求：可只指定行数，不可单独指定列数

// 先定义行数，再逐行分配列数
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[4];
arr[2] = new int[3];