JavaSE3️⃣程序基础 - 数组

数组（array）：相同类型数据的有序集合。

1、一维数组

1.1、语法

数据类型[] 定义数组变量，new 初始化数组实例。

初始化分为两种情况：

动态初始化：指定数组长度。

静态初始化：指定内容，由 Java 推断数组长度。

// 动态
int[] nums1 = new int[3];

// 静态
int[] nums2 = new int[] {83, 97, 62};
int[] nums3 = {83, 97, 62};

1.2、访问数组

数组元素：通过 数组名[索引] 实现读和写，索引从 0 开始。

数组长度：通过 数组名.length 访问。

int[] nums = new int[5];

// 读
System.out.println(nums[0]);	// 0
// 写
nums[0] = 100;

// 长度
System.out.println(nums.length);	// 5

1.3、特点

数据类型：数组是引用类型。
容量大小：数组一旦创建，容量不可变。
默认值：数组初始化后，所有元素都是默认值（基本类型对应默认值，引用类型 null）。
下标越界：若访问数组元素时索引超出范围，会报错 IndexOutOfBoundsException。

2、引用关系

数组变量保存了实例在堆中的内存地址，是对数组内存地址的引用。

下文讲解不同类型数组中的变量引用关系。

2.1、基本类型

以 int 数组为例

// 初始化
int[] ns = new int[] {1, 2, 3, 4};
// 重新赋值
ns = new int[] {10, 20, 30};

初始化：在堆内存开辟一块连续的内存空间，初始化数组。

（变量 ns 指向该内存空间）

     ns
      │
      ▼
┌───┬───┬───┬───┬───┬───┐
│   │ 1 │ 2 │ 3 │ 4 │   │
└───┴───┴───┴───┴───┴───┘

重新赋值：在堆内存开辟另一块连续的内存空间，初始化数组。

（原数组没有改变，而是修改了 ns 的变量引用）

     ns ──────────────────────┐
                              │
                              ▼
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐───┐
│   │ 1 │ 2 │ 3 │ 4 │   │   │10 │20 │30 │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘───┘

2.2、引用类型

引用类型数组的引用关系较复杂。

以 String 数组为例

String[] arrays = {"AA", "BB", "CC"}

arrays[1] = "XX";

初始化：在内存开辟一块连续的内存空间，初始化数组。

数组是引用类型，变量 arrays 指向数组实例。

数组元素也是引用类型，指向内存中对应的对象实例。

          ┌─────────────┐
   arrays │   ┌─────────┼───────────────────────┐
      │   │   │         │                       │
      ▼   │   │         ▼                       ▼
┌───┬───┬─┴─┬─┴─┬───┬──────┬───┬──────┬───┬──────┬───┐
│   │░░░│░░░│░░░│   │ "BB" │   │ "AA" │   │ "CC" │   │
└───┴─┬─┴───┴───┴───┴──────┴───┴──────┴───┴──────┴───┘
      │                           ▲
      └───────────────────────────┘

重新赋值：在内存中创建新的 String 实例，修改属性的引用。

          ┌─────────────────────────────────────────────┐
   arrays │   ┌──────────────────────────────┐          │
      │   │   │                              │          │
      ▼   │   │                              ▼          ▼
┌───┬───┬─┴─┬─┴─┬───┬──────┬───┬──────┬───┬──────┬───┬──────┬───┐
│   │░░░│░░░│░░░│   │ "BB" │   │ "AA" │   │ "CC" │   │ "XX" │   │
└───┴─┬─┴───┴───┴───┴──────┴───┴──────┴───┴──────┴───┴──────┴───┘
      │                           ▲
      └───────────────────────────┘

Hint：数组本身是引用类型。

相比基本类型数组，引用类型数组多了一层指向关系。

3、多维数组

多维数组：一维数组的拓展，常见的是二维和三维数组。

语法、使用方式等基本相同。

3.1、二维数组

二维数组：一维数组的数组。

即每个数组元素是一维数组。

语法：数组类型[][]，支持动态、静态初始化。
访问数组：
1. 数组元素：通过 数组名[行索引][列索引] 实现读写，索引从 0 开始。
2. 数组长度：
  1. 行数：通过 数组名.length 访问。
  2. 列数：通过 数组名[行索引].length 访问。
特点：Java 中的多维数组，允许不同数组的长度不同。

示例

代码：

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

// 访问数组元素
System.out.println(nums[1][3]);	// 7
// 数组长度
System.out.println(nums.length);	// 3
System.out.println(nums[1].length);	// 4

结构示意：

                    ┌───┬───┬───┐
         ┌───┐  ┌──▶│ 1 │ 2 │ 3 │
ns ─────▶│░░░│──┘   └───┴───┴───┘
         ├───┤      ┌───┬───┬───┬───┐
         │░░░│─────▶│ 4 │ 5 │ 6 │ 7 │
         ├───┤      └───┴───┴───┴───┘
         │░░░│──┐   ┌───┬───┐
         └───┘  └──▶│ 8 │ 9 │
                    └───┴───┘

3.2、三维数组

三维数组：二维数组的数组。

即每个数组元素是二维数组。

语法：数组类型[][][]，支持动态、静态初始化。
访问数组：
1. 数组元素：通过 数组名[索引][行索引][列索引] 实现读写，索引从 0 开始。
2. 数组长度：类比二维数组。
说明：在实际应用中，通常最多使用二维数组，很少使用更高数组。

示例

初始化并访问：

int[][][] nums = {
    {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    },
    {
        {10, 11},
        {12, 13}
    }
};

// 访问数组元素
System.out.println(nums[0][1][2]);	// 6
// 数组长度
System.out.println(nums.length);	// 2