代码随想录day1——about arrays（关于数组）数组是编程中的一种基础数据结构，用于存储多个相同类型的数据。数

数组是编程中的一种基础数据结构，用于存储多个相同类型的数据。数组在内存中是连续存储的，这使得它可以通过索引来快速访问元素。Java语言中的数组是对象，具有固定的长度和类型，并且能够在创建时指定大小或直接初始化。下面是笔者关于数组的一些浅薄看法。

1. 数组的定义与创建

在Java中，数组是通过声明变量并使用 new 关键字来创建的。数组可以存储基本数据类型的元素，也可以存储对象。

定义与创建数组

// 创建一个整数类型的数组，大小为5
int[] arr = new int[5];

数组初始化

数组在创建时可以进行初始化，元素会被默认初始化为相应类型的默认值（对于基本类型，int默认为0，boolean为false，引用类型为null）。

int[] arr = new int[5];  // 所有元素的值默认为0

2. 数组的访问与操作

数组的元素通过索引来访问，索引从0开始。可以通过下标来获取或设置数组中的元素。

获取数组元素

int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr[0]);  // 输出第一个元素: 1

设置数组元素

arr[2] = 10;  // 将第三个元素设置为10
System.out.println(arr[2]);  // 输出第三个元素: 10

3. 数组的长度

数组的长度是固定的，一旦创建后不能改变。可以使用 length 属性获取数组的大小。

int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr.length);  // 输出数组的长度: 5

4. 多维数组

Java支持多维数组。常见的多维数组是二维数组，类似于矩阵。多维数组实际上是数组的数组。

创建二维数组

// 创建一个3x3的二维数组
int[][] matrix = new int[3][3];

初始化二维数组

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

访问二维数组元素

System.out.println(matrix[0][0]);  // 输出第一行第一列元素: 1
System.out.println(matrix[2][2]);  // 输出第三行第三列元素: 9

迭代二维数组

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();  // 换行
}

5. 数组的遍历

数组可以通过循环进行遍历。最常见的是使用 for 循环或增强型 for 循环（也叫做“for-each”循环）来遍历。

使用传统的 `for` 循环

int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

使用增强型 `for` 循环（for-each）

int[] arr = {1, 2, 3, 4, 5};
for (int num : arr) {
    System.out.print(num + " ");
}

6. 数组的复制

Java提供了一些方法来复制数组。常见的复制方式有 System.arraycopy() 和 Arrays.copyOf()。

使用 `System.arraycopy()`

int[] arr = {1, 2, 3, 4, 5};
int[] newArr = new int[5];
System.arraycopy(arr, 0, newArr, 0, arr.length);

使用 `Arrays.copyOf()`

import java.util.Arrays;

int[] arr = {1, 2, 3, 4, 5};
int[] newArr = Arrays.copyOf(arr, arr.length);  // 创建一个与原数组相同的新数组

7. 数组的排序

Java提供了 Arrays.sort() 方法对数组进行排序。默认情况下，Arrays.sort() 对数字进行升序排序。

对数组排序

import java.util.Arrays;

int[] arr = {5, 2, 8, 1, 3};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));  // 输出: [1, 2, 3, 5, 8]

8. 数组的常见操作方法

Java提供了 Arrays 类中的一些常见方法来操作数组，例如查找元素、填充数组、比较数组等。

填充数组

import java.util.Arrays;
int[] arr = new int[5];
Arrays.fill(arr, 7);  // 将所有元素填充为7
System.out.println(Arrays.toString(arr));  // 输出: [7, 7, 7, 7, 7]

数组的比较

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);  // 比较两个数组是否相等
System.out.println(isEqual);  // 输出: true

数组查找元素

import java.util.Arrays;
int[] arr = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(arr, 3);  // 二分查找元素3
System.out.println(index);  // 输出: 2

9. 数组在内存中的存储方式

在大多数编程语言（包括Java）中，数组的元素在内存中是连续存储的。也就是说，数组中的每个元素都占据相邻的内存位置。这是数组的一个重要特性，使得通过索引访问数组元素非常高效，因为数组的元素可以通过数学公式直接计算出对应的内存地址。

数组元素的内存存储

假设我们有一个数组 arr，其元素类型为基本数据类型（如 int）：

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

在内存中，arr 数组的元素是按照顺序连续存储的。例如，对于 int[] 数组，每个元素通常占据 4 个字节（在大多数 Java 实现中，int 类型占 4 字节），因此每个元素的内存地址相差 4 字节。
数组本身是一个对象，在堆内存中分配空间。数组对象的内存地址存储的是指向该数组首元素的指针。

数组名与内存地址

在Java中，数组名代表的是数组对象的引用（即数组的内存地址）。这个引用指向了数组的起始位置，即数组中第一个元素的地址。

int[] arr = {10, 20, 30, 40};
System.out.println(arr);  // 输出数组的内存地址（对象引用）

arr 实际上是数组对象的引用，它指向数组的起始地址。
访问数组时，可以通过数组的索引来访问元素。每个元素的内存地址是通过数组起始地址加上偏移量来计算的。

数组元素的内存地址计算

假设数组是由元素类型为 T 的元素构成的，数组的起始地址为 baseAddress，每个元素的大小为 size(T)，第 i 个元素的地址可以通过如下公式计算：

address(arr[i]) = baseAddress + (i * size(T))

这里，arr[i] 代表数组中的第 i 个元素，baseAddress 是数组起始位置的内存地址，size(T) 是元素的大小，i 是元素的索引。
例如，在 int[] arr = {10, 20, 30, 40}; 中，每个 int 占用 4 字节，因此 arr[1] 的内存地址将是 arr[0] 地址加上 4 字节。

数组的连续内存分配

数组中数据的连续存储特性使得访问元素非常高效。例如，对于一个一维数组 arr，它在内存中是一个连续的块，不同于链表等数据结构（链表中的节点可以分布在内存中的不同位置）。

连续存储的优点：

快速访问：通过索引可以直接计算出元素的内存地址，无需像链表那样遍历节点，因此访问数组的时间复杂度是 O(1)。
内存效率：由于数组元素在内存中是紧凑的连续存储，内存利用率较高。

连续存储的缺点：

大小固定：数组的大小一旦确定，就不能动态改变。若数组需要扩容，则需要创建新的更大的数组并将旧数组的元素复制过去。
插入删除不便：在数组中间插入或删除元素会涉及到大量元素的移动，效率较低。

数组对象的引用与元素地址

在 Java 中，数组本身是一个对象，且数组的引用指向数组对象的起始地址。数组对象的引用可以在内存中找到，而数组中的每个元素则占用固定的内存位置。

数组对象引用的存储：

当你声明一个数组时，例如：int[] arr = new int[5];，内存中会分配两个主要的部分：
1. 数组对象本身（在堆内存中）。它包含数组的元数据（如长度等信息）和指向数组元素的指针。
2. 数组元素（在堆内存中），这些元素是连续存储的。
通过 arr 可以获取数组对象的引用，这个引用指向了数组的首地址。要访问某个特定元素，则需要在这个地址基础上加上索引偏移量。

数组在堆和栈中的存储位置

数组对象（数组本身）是在堆上分配的，因为它是一个引用类型（在Java中，所有对象都在堆上分配）。
数组元素存储在堆内存中的数组对象内部，因此元素也是在堆中连续存储的。

对于普通的局部变量（如基本数据类型的变量），它们通常存储在栈上。数组的引用（即数组对象的内存地址）会被存储在栈上，但数组的实际数据存储在堆内存中。

10. 浅拷贝与深拷贝

数组的拷贝也涉及内存地址的处理。Java中的数组拷贝是浅拷贝（shallow copy），即复制的是数组对象的引用（指针），而不是数组的元素本身。这样，如果对新数组进行修改，原数组的内容可能也会改变，除非使用深拷贝。

浅拷贝

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;  // arr2 只是 arr1 的引用
arr2[0] = 10;
System.out.println(arr1[0]);  // 输出 10，因为 arr1 和 arr2 指向同一个数组对象

深拷贝

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1.clone();  // 使用 clone() 进行深拷贝
arr2[0] = 10;
System.out.println(arr1[0]);  // 输出 1，原数组 arr1 没有被改变

总结

数组是连续存储的，其元素在内存中是顺序排列的，可以通过索引计算出元素的内存地址。
数组名代表的是数组对象的引用，即数组的起始地址。
数组的内存地址计算可以通过基础的地址偏移公式 address(arr[i]) = baseAddress + (i * size(T)) 来实现。
在 Java 中，数组元素的存储是在堆内存中，数组对象的引用（指向数组的内存地址）存储在栈内存中。
数组的拷贝通常是浅拷贝，但可以使用方法如 clone() 来实现深拷贝。

代码随想录day1——about arrays（关于数组）