C#基础入门篇 (5.数组详解)

------

## 数组基础

### 定义

- **数组**是相同类型元素的固定大小连续集合。
- 通过索引访问元素（从0开始）。
- 属于引用类型（存储在堆内存中）。

### 特点

- 固定长度（使用`Array.Resize`可间接调整）
- 内存连续分配，访问高效
- 支持多维和交错结构

------

## 数组声明与初始化

### 一维数组

```
// 声明
int[] arr1;

// 初始化方式1：指定大小
int[] arr2 = new int[5];  // 默认值填充（int为0）

// 初始化方式2：直接赋值
int[] arr3 = new int[] { 1, 2, 3, 4, 5 };

// 简化语法
int[] arr4 = { 10, 20, 30 };
```

### 多维数组

```
// 二维数组（矩形数组）
int[,] matrix = new int[3, 4];  // 3行4列

// 初始化时赋值
int[,] scores = {
    {90, 85, 92},
    {78, 86, 89},
    {88, 94, 81}
};
```

### 交错数组（数组的数组）

```
int[][] jagged = new int[3][];  // 3个子数组
jagged[0] = new int[] {1, 2};
jagged[1] = new int[] {3, 4, 5};
jagged[2] = new int[] {6};
```

------

## 数组访问与遍历

### 基本访问

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

// 通过索引访问
Console.WriteLine(numbers[0]);  // 输出10
numbers[2] = 99;                // 修改第三个元素
```

### 遍历方法

**for循环**

```
for (int i = 0; i < numbers.Length; i++) {
    Console.WriteLine(numbers[i]);
}
```

**foreach循环**

```
foreach (int num in numbers) {
    Console.WriteLine(num);
}
```

------

## 数组操作

### 常用属性

| 属性     | 说明                  |
| :------- | :-------------------- |
| `Length` | 数组总元素数量        |
| `Rank`   | 数组维度数（一维为1） |

### 常用方法

| 方法                 | 说明                           |
| :------------------- | :----------------------------- |
| `Array.Clone()`      | 创建浅拷贝                     |
| `Array.Copy()`       | 复制元素到新数组               |
| `Array.Resize()`     | 调整数组大小（实际创建新数组） |
| `Array.IndexOf()`    | 查找元素索引                   |
| `Array.Sort()`       | 排序数组                       |
| `Array.Reverse()`    | 反转数组顺序                   |
| `Array.ConvertAll()` | 类型转换                       |

### 示例代码

```
// 数组复制
int[] source = { 1, 2, 3 };
int[] dest = new int[5];
Array.Copy(source, dest, 3);

// 调整大小
Array.Resize(ref source, 5);

// 类型转换
string[] strArr = { "1", "2", "3" };
int[] intArr = Array.ConvertAll(strArr, int.Parse);
```

------

## 多维数组

### 访问与遍历

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

// 访问元素
Console.WriteLine(matrix[1, 2]);  // 输出6

// 遍历所有元素
for (int i = 0; i < matrix.GetLength(0); i++) {
    for (int j = 0; j < matrix.GetLength(1); j++) {
        Console.Write(matrix[i, j] + " ");
    }
    Console.WriteLine();
}
```

------

## 交错数组

### 初始化与访问

```
int[][] jagged = new int[3][];
jagged[0] = new int[] {1, 2};
jagged[1] = new int[] {3, 4, 5};
jagged[2] = new int[] {6};

// 访问元素
Console.WriteLine(jagged[1][2]);  // 输出5

// 遍历
foreach (int[] subArray in jagged) {
    foreach (int num in subArray) {
        Console.Write(num + " ");
    }
    Console.WriteLine();
}
```

------

## 常用数组操作示例

### 1. 查找最大值

```
int[] arr = { 12, 45, 67, 23, 9 };
int max = arr[0];
foreach (int num in arr) {
    if (num > max) max = num;
}
Console.WriteLine($"最大值: {max}");
```

### 2. 数组反转

```
Array.Reverse(arr);
// 或手动实现：
for (int i = 0; i < arr.Length / 2; i++) {
    int temp = arr[i];
    arr[i] = arr[arr.Length - 1 - i];
    arr[arr.Length - 1 - i] = temp;
}
```

### 3. 元素存在性检查

```
bool exists = Array.Exists(arr, element => element == 23);
// 或使用LINQ
bool exists = arr.Contains(23);
```

------

## 性能与注意事项

### 最佳实践

1. **固定大小**：频繁增删时考虑使用`List`
2. **内存连续性**：访问相邻元素性能更优
3. **边界检查**：始终验证索引范围
4. **复制优化**：优先使用`Array.Copy`而非循环

### 与`List`对比

| 特性     | Array  | List<T>        |
| :------- | :----- | :------------- |
| 大小     | 固定   | 动态扩展       |
| 内存     | 连续   | 动态分配       |
| 性能     | 访问快 | 增删操作更高效 |
| 功能方法 | 较少   | 丰富的方法支持 |

------

## 附录：Array类静态方法速查

| 方法签名                            | 说明                     |
| :---------------------------------- | :----------------------- |
| `Array.BinarySearch(array, value)`  | 二分查找（需已排序）     |
| `Array.Clear(array, index, length)` | 重置元素为默认值         |
| `Array.Find(array, predicate)`      | 查找满足条件的第一个元素 |
| `Array.FindAll(array, predicate)`   | 返回所有匹配元素的数组   |
| `Array.ForEach(array, action)`      | 对每个元素执行操作       |

------

> **提示**：在.NET 6+中，可以使用`Span`和`Memory`进行更高效的数组操作。
> **注意**：数组越界访问会抛出`IndexOutOfRangeException`！