数组的定义与初始化

数组是存储多个同类型元素的容器。

数组概念

什么是数组

数组是固定长度的同类型元素集合，存储在连续内存中。

// 数组特点
// 1. 固定长度（创建后不可改变）
// 2. 元素类型相同
// 3. 索引从0开始
// 4. 连续内存存储

数组声明语法

// 声明数组变量
int[] arr;        // 推荐写法
int arr[];        // 也可用（不推荐）

String[] names;   // 字符串数组
double[] prices;  // double数组

数组创建与初始化

使用new创建数组

// 创建指定长度数组
int[] arr = new int[5];  // 创建长度为5的int数组

// 默认值：
// int: 0
// double: 0.0
// boolean: false
// String/对象: null

System.out.println(arr[0]);  // 0（默认值）
System.out.println(arr.length);  // 5

直接初始化数组

// 声明并初始化
int[] arr1 = {1, 2, 3, 4, 5};

// 等价于
int[] arr2 = new int[]{1, 2, 3, 4, 5};

// 长度由元素个数决定
System.out.println(arr1.length);  // 5

分步创建

// 1. 先声明
int[] arr;

// 2. 后创建
arr = new int[3];

// 3. 再赋值
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;

各类型数组初始化

基本类型数组

// int数组
int[] nums = {1, 2, 3};

// double数组
double[] prices = {10.5, 20.0, 30.5};

// boolean数组
boolean[] flags = {true, false, true};

// char数组
char[] chars = {'A', 'B', 'C'};

引用类型数组

// String数组
String[] names = {"张三", "李四", "王五"};

// 自定义类数组
Student[] students = new Student[3];
students[0] = new Student("张三");
students[1] = new Student("李四");
students[2] = new Student("王五");

默认值对照表

int[] arr = new int[5];
// 所有元素为0

String[] names = new String[3];
// 所有元素为null

数组访问

通过索引访问

int[] arr = {10, 20, 30, 40, 50};

// 读取元素（索引从0开始）
int first = arr[0];   // 10
int second = arr[1];  // 20
int last = arr[4];    // 50

// 修改元素
arr[0] = 100;
arr[2] = 300;

数组索引规则

• 索引从0开始
• 最大索引为length-1
• 越界访问抛ArrayIndexOutOfBoundsException

int[] arr = new int[3];

// 有效索引：0, 1, 2
// arr[-1];  // 错误：越界
// arr[3];   // 错误：越界

length属性

int[] arr = {1, 2, 3, 4, 5};

// 获取数组长度
int len = arr.length;  // 5（注意：length是属性，不是方法）

// 最后一个元素
int last = arr[arr.length - 1];

多维数组

二维数组

// 声明二维数组
int[][] matrix;

// 创建并初始化
int[][] matrix1 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 使用new创建
int[][] matrix2 = new int[3][4];  // 3行4列

// 访问元素
int val = matrix1[0][1];  // 2（第0行第1列）

不规则二维数组

// 每行长度不同
int[][] arr = new int[3][];  // 先指定行数

arr[0] = new int[2];  // 第0行2列
arr[1] = new int[3];  // 第1行3列
arr[2] = new int[4];  // 第2行4列

二维数组遍历

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};

// 遍历所有元素
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.println(matrix[i][j]);
    }
}

数组与内存

数组内存结构

int[] arr = {1, 2, 3};

// 栈内存：存储arr引用（地址）
// 堆内存：存储数组对象和元素

// 数组引用在栈，数组实体在堆

数组引用

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;  // arr2指向arr1同一数组

arr2[0] = 100;
System.out.println(arr1[0]);  // 100（同一数组）

// arr1和arr2是同一数组的两个引用

数组注意事项

数组长度不可变

int[] arr = new int[3];

// 数组长度固定，不能改变
// 想要"扩容"需要创建新数组
int[] newArr = new int[5];
// 复制旧数组元素到新数组

空数组与null

// 空数组：长度为0的数组
int[] empty = new int[0];
empty.length;  // 0

// null：没有指向任何数组
int[] nullArr = null;
// nullArr.length;  // NullPointerException

数组初始化完整示例

// 完整流程示例
public class ArrayDemo {
    public static void main(String[] args) {
        // 方式1：直接初始化
        int[] arr1 = {1, 2, 3};
        
        // 方式2：new初始化
        int[] arr2 = new int[]{1, 2, 3};
        
        // 方式3：分步创建
        int[] arr3;
        arr3 = new int[3];
        arr3[0] = 1;
        arr3[1] = 2;
        arr3[2] = 3;
        
        // 输出
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
    }
}

要点总结

• 数组是固定长度的同类型元素集合
• 声明语法：int[] arr 或 int arr[]（推荐前者）
• 创建数组：new int[长度] 或 {元素列表}
• 索引从0开始，最大索引为length-1
• length属性获取数组长度（不是方法）
• 基本类型数组默认值：数字为0，boolean为false
• 引用类型数组默认值：null
• 索引越界抛ArrayIndexOutOfBoundsException
• 数组引用在栈，实体在堆
• 数组长度创建后不可改变
• 二维数组：int[][] matrix = new int[行][列]

articles/JAVA/入门/数组与方法/数组的定义与初始化.md