C# 程序设计基础之 - 数组

在C#中，数组是一种用于存储固定大小的相同类型元素集合的数据结构。数组可以是一维的，也可以是二维或多维的。

1. 数组的基本概念

1.1 定义与用途

数组是一种基本的数据结构，用于存储相同类型的元素集合。在C#中，数组是一种引用类型，它在内存中分配一块连续的空间来存储元素。数组的定义格式如下：

数据类型[] 数组名 = new 数据类型[数组长度];

例如：

int[] myArray = new int[5];

这表示创建了一个长度为5的整型数组myArray。数组的用途非常广泛，例如：

• 存储一组相关数据，如学生的成绩、商品的价格等。

• 通过索引快速访问和修改数据，提高程序的效率。

• 用于数据的排序、搜索等操作。

• 在循环中处理大量数据，简化代码逻辑。

1.2 数据类型与维度

在C#中，数组可以存储各种数据类型，包括基本数据类型（如int、float、char等）和引用类型（如string、class等）。例如：

float[] floatArray = new float[3]; // 浮点型数组
string[] stringArray = new string[4]; // 字符串数组

数组的维度是指数组的维度数量。C#支持一维数组、多维数组和锯齿数组：

• 一维数组：是最简单的数组形式，只有一个维度，用于存储线性数据。例如：

• int[] oneDimensionalArray = new int[10];

• 多维数组：可以存储二维或更高维度的数据。例如，二维数组可以用于表示矩阵或表格。定义格式如下：

数据类型[,] 多维数组名 = new 数据类型[行数, 列数];

例如：

• int[,] matrix = new int[3, 4]; // 3行4列的二维数组

• 锯齿数组：是一种特殊的多维数组，其中每个“行”可以有不同的长度。定义格式如下：

数据类型[][] 锯齿数组名 = new 数据类型[行数][];

例如：

• int[][] jaggedArray = new int[3][];
  jaggedArray[0] = new int[2];
  jaggedArray[1] = new int[3];
  jaggedArray[2] = new int[4];

不同类型的数组在实际应用中各有优势，选择合适的数组类型可以提高程序的性能和可读性。

2. 数组的声明与初始化

2.1 单维数组声明与初始化

在C#中，单维数组是最基本的数组形式，用于存储线性数据。单维数组的声明和初始化有多种方式，以下分别介绍。

声明数组

声明单维数组的基本语法如下：

数据类型[] 数组名;

例如，声明一个整型数组：

int[] myArray;

此时，myArray只是一个数组变量的声明，它还没有分配内存空间，不能直接使用。

初始化数组

初始化数组是指为数组分配内存空间，并可以给数组元素赋初值。以下是几种常见的初始化方式。

使用new关键字初始化

数据类型[] 数组名 = new 数据类型[数组长度];

例如：

int[] myArray = new int[5];

这表示创建了一个长度为5的整型数组myArray，所有元素的初始值为该数据类型的默认值（对于int类型，默认值为0）。

在声明时直接初始化

数据类型[] 数组名 = {元素1, 元素2, ..., 元素n};

例如：

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

这种方式不需要指定数组的长度，编译器会根据提供的元素个数自动确定数组长度。

分两步初始化

先声明数组变量，再使用new关键字初始化：

数据类型[] 数组名;
数组名 = new 数据类型[数组长度];

例如：

int[] myArray;
myArray = new int[5];

这种方式在某些情况下比较灵活，比如在方法中根据参数动态分配数组大小。

访问和修改数组元素

数组元素通过索引访问，索引从0开始。例如：

int firstElement = myArray[0]; // 访问第一个元素
myArray[1] = 10; // 修改第二个元素的值

2.2 多维数组声明与初始化

C#支持多维数组，包括二维数组、三维数组等。多维数组的声明和初始化方式与单维数组类似，但需要指定多个维度的大小。

二维数组

声明二维数组

数据类型[,] 数组名;

例如：

int[,] matrix;

初始化二维数组

使用new关键字初始化

数据类型[,] 数组名 = new 数据类型[行数, 列数];

例如：

int[,] matrix = new int[3, 4];

这表示创建了一个3行4列的二维数组matrix，所有元素的初始值为该数据类型的默认值。

在声明时直接初始化

数据类型[,] 数组名 = { {元素11, 元素12, ...}, {元素21, 元素22, ...}, ... };

例如：

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

这种方式不需要指定数组的大小，编译器会根据提供的元素自动确定行数和列数。

三维数组

声明三维数组

数据类型[,,] 数组名;

例如：

int[,,] cube;

初始化三维数组

使用new关键字初始化

数据类型[,,] 数组名 = new 数据类型[维度1大小, 维度2大小, 维度3大小];

例如：

int[,,] cube = new int[2, 3, 4];

这表示创建了一个2×3×4的三维数组cube，所有元素的初始值为该数据类型的默认值。

在声明时直接初始化

数据类型[,,] 数组名 = { { {元素111, 元素112, ...}, {元素121, 元素122, ...}, ... }, { {元素211, 元素212, ...}, {元素221, 元素222, ...}, ... }, ... };

例如：

int[,,] cube = { { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} }, { {13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24} } };

访问和修改多维数组元素

多维数组的元素通过多个索引访问。例如，对于二维数组matrix：

int element = matrix[0, 1]; // 访问第一行第二列的元素
matrix[1, 2] = 100; // 修改第二行第三列的元素值

对于三维数组cube：

int element = cube[0, 1, 2]; // 访问第一层第二行第三列的元素
cube[1, 2, 3] = 200; // 修改第二层第三行第四列的元素值

3. 数组的操作

3.1 访问数组元素

在C#中，数组元素的访问是通过索引来实现的。数组的索引从0开始，这意味着第一个元素的索引是0，第二个元素的索引是1，依此类推。访问数组元素的基本语法如下：

数组名[索引]

例如，对于一个一维数组myArray，可以通过以下方式访问其第一个元素：

int firstElement = myArray[0];

对于多维数组，需要使用多个索引。例如，对于一个二维数组matrix，可以通过以下方式访问其第一行第二列的元素：

int element = matrix[0, 1];

对于三维数组cube，可以通过以下方式访问其第一层第二行第三列的元素：

int element = cube[0, 1, 2];

访问数组元素时，需要注意索引的范围。如果索引超出了数组的有效范围，程序会抛出IndexOutOfRangeException异常。例如，对于一个长度为5的数组myArray，尝试访问myArray[5]会导致异常，因为有效的索引范围是0到4。

此外，数组的Length属性可以用来获取数组的长度。对于一维数组，Length表示数组的元素个数；对于多维数组，Length表示数组中所有元素的总数。例如：

int arrayLength = myArray.Length;

对于二维数组matrix，可以通过GetLength方法获取其行数和列数：

int rows = matrix.GetLength(0); // 获取行数
int cols = matrix.GetLength(1); // 获取列数

通过这些方法，可以动态地访问数组中的元素，而无需硬编码索引值。

3.2 修改数组元素

修改数组元素的值也是通过索引来实现的。基本语法如下：

数组名[索引] = 新值;

例如，对于一个一维数组myArray，可以通过以下方式修改其第二个元素的值：

myArray[1] = 10;

对于多维数组，修改元素的值需要指定多个索引。例如，对于一个二维数组matrix，可以通过以下方式修改其第二行第三列的元素值：

matrix[1, 2] = 100;

对于三维数组cube，可以通过以下方式修改其第二层第三行第四列的元素值：

cube[1, 2, 3] = 200;

修改数组元素时，同样需要注意索引的范围。如果索引超出了数组的有效范围，程序会抛出IndexOutOfRangeException异常。例如，对于一个长度为5的数组myArray，尝试修改myArray[5]会导致异常，因为有效的索引范围是0到4。

此外，数组的元素类型决定了可以赋值的类型。例如，对于一个整型数组int[] myArray，只能将整数值赋给数组元素。如果尝试将非整数值赋给数组元素，程序会抛出编译错误。例如：

myArray[0] = "Hello"; // 错误：不能将字符串赋值给整型数组元素

在实际开发中，修改数组元素的值通常用于实现数据的更新和处理。例如，在一个学生成绩数组中，可以根据学生的考试成绩修改数组中的对应元素值。或者在图像处理中，可以通过修改像素数组的值来实现图像的编辑和处理。

4. 遍历数组

4.1 使用 for 循环遍历数组

在 C# 中，for 循环是一种常用的循环结构，可以用来遍历数组中的每个元素。通过 for 循环，可以灵活地控制循环的起始条件、终止条件和步长，从而实现对数组的逐个访问。

基本语法

使用 for 循环遍历一维数组的基本语法如下：

for (初始化; 循环条件; 步长)
{
    // 循环体
}

其中：

• 初始化：通常用于声明和初始化循环变量，例如 int i = 0。

• 循环条件：每次循环开始前都会检查的条件，如果条件为 true，则继续执行循环体；如果为 false，则退出循环。

• 步长：每次循环结束后对循环变量的更新操作，例如 i++。

示例

假设有一个一维数组 int[] myArray = { 1, 2, 3, 4, 5 };，可以通过以下方式使用 for 循环遍历数组中的每个元素：

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

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

输出结果为：

1
2
3
4
5

多维数组的遍历

对于多维数组，可以使用嵌套的 for 循环来遍历数组中的每个元素。例如，对于一个二维数组 int[,] matrix = { { 1, 2, 3 }, { 4, 5, 6 } };，可以通过以下方式遍历：

int[,] matrix = { { 1, 2, 3 }, { 4, 5, 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();
}

输出结果为：

1 2 3
4 5 6

锯齿数组的遍历

对于锯齿数组，由于每一行的长度可能不同，因此需要分别处理每一行。例如，对于一个锯齿数组 int[][] jaggedArray = new int[3][];，可以通过以下方式遍历：

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

for (int i = 0; i < jaggedArray.Length; i++) // 遍历行
{
    for (int j = 0; j < jaggedArray[i].Length; j++) // 遍历当前行的列
    {
        Console.Write(jaggedArray[i][j] + " ");
    }
    Console.WriteLine();
}

输出结果为：

1 2
3 4 5
6 7 8 9

4.2 使用 foreach 循环遍历数组

foreach 循环是一种更简洁的循环结构，专门用于遍历数组或集合中的每个元素。使用 foreach 循环时，不需要手动管理索引，代码更加简洁易读。

基本语法

使用 foreach 循环遍历数组的基本语法如下：

foreach (数据类型 变量名 in 数组名)
{
    // 循环体
}

其中：

• 数据类型：数组中元素的类型。

• 变量名：用于存储当前遍历到的元素的变量。

• 数组名：要遍历的数组。

示例

假设有一个一维数组 int[] myArray = { 1, 2, 3, 4, 5 };，可以通过以下方式使用 foreach 循环遍历数组中的每个元素：

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

foreach (int element in myArray)
{
    Console.WriteLine(element);
}

输出结果为：

1
2
3
4
5

多维数组的遍历

对于多维数组，foreach 循环会按照行优先的顺序依次访问数组中的每个元素。例如，对于一个二维数组 int[,] matrix = { { 1, 2, 3 }, { 4, 5, 6 } };，可以通过以下方式遍历：

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

foreach (int element in matrix)
{
    Console.Write(element + " ");
}

输出结果为：

1 2 3 4 5 6

锯齿数组的遍历

对于锯齿数组，foreach 循环同样可以用于遍历数组中的每个元素。例如，对于一个锯齿数组 int[][] jaggedArray = new int[3][];，可以通过以下方式遍历：

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

foreach (int[] row in jaggedArray) // 遍历每一行
{
    foreach (int element in row) // 遍历当前行的每个元素
    {
        Console.Write(element + " ");
    }
    Console.WriteLine();
}

输出结果为：

1 2
3 4 5
6 7 8 9

注意事项

• foreach 循环只能用于遍历数组中的元素，不能直接修改数组元素的值。如果需要修改数组元素，可以使用 for 循环。

• foreach 循环在遍历多维数组时，会将数组中的所有元素按照行优先的顺序依次访问，而不是按照二维数组的行列结构访问。如果需要按照行列结构访问多维数组，建议使用嵌套的 for 循环。

5. 数组的常用方法

5.1 数组排序

在C#中，数组排序是常见的操作，主要用于对数组中的元素按照一定顺序进行排列。C#提供了多种排序方法，其中最常用的是使用Array.Sort方法。

Array.Sort方法

Array.Sort方法是C#中用于对数组进行排序的内置方法。它默认按照升序对数组中的元素进行排序，但也可以通过指定比较器来实现降序或其他自定义排序。

升序排序

对于一维数组，可以直接使用Array.Sort方法进行升序排序。例如：

int[] myArray = { 5, 2, 9, 1, 5, 6 };
Array.Sort(myArray);
foreach (int element in myArray)
{
    Console.Write(element + " ");
}

输出结果为：

1 2 5 5 6 9

降序排序

要实现降序排序，可以使用Array.Sort方法结合Comparer类。例如：

int[] myArray = { 5, 2, 9, 1, 5, 6 };
Array.Sort(myArray, Comparer<int>.Create((x, y) => y.CompareTo(x)));
foreach (int element in myArray)
{
    Console.Write(element + " ");
}

输出结果为：

9 6 5 5 2 1

自定义排序

对于复杂数据类型的数组，可以通过实现IComparer接口来自定义排序逻辑。例如，对于一个Person类的数组，可以根据年龄进行排序：

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class AgeComparer : IComparer<Person>
{
    public int Compare(Person x, Person y)
    {
        return x.Age.CompareTo(y.Age);
    }
}

Person[] people = { new Person { Name = "Alice", Age = 30 }, new Person { Name = "Bob", Age = 25 }, new Person { Name = "Charlie", Age = 35 } };
Array.Sort(people, new AgeComparer());
foreach (Person person in people)
{
    Console.WriteLine($"{person.Name} - {person.Age}");
}

输出结果为：

Bob - 25
Alice - 30
Charlie - 35

多维数组排序

对于多维数组，Array.Sort方法不直接适用，因为多维数组的元素是按照行优先顺序存储的。如果需要对多维数组的某一行或某一列进行排序，可以先将该行或列提取为一维数组，然后进行排序，最后再将排序后的结果放回原位置。

例如，对二维数组的某一列进行排序：

int[,] matrix = { { 5, 2, 9 }, { 1, 5, 6 }, { 3, 8, 4 } };
int columnIndex = 1; // 对第二列进行排序
int rows = matrix.GetLength(0);
int[] columnValues = new int[rows];

// 提取第二列的值
for (int i = 0; i < rows; i++)
{
    columnValues[i] = matrix[i, columnIndex];
}

// 对提取的列值进行排序
Array.Sort(columnValues);

// 将排序后的值放回原位置
for (int i = 0; i < rows; i++)
{
    matrix[i, columnIndex] = columnValues[i];
}

// 输出排序后的二维数组
for (int i = 0; i < rows; i++)
{
    for (int j = 0; j < matrix.GetLength(1); j++)
    {
        Console.Write(matrix[i, j] + " ");
    }
    Console.WriteLine();
}

输出结果为：

5 2 9
1 5 6
3 8 4

5.2 数组查找

在C#中，数组查找是常见的操作，用于在数组中查找特定元素的位置或是否存在某个元素。C#提供了多种查找方法，其中最常用的是Array.IndexOf方法和Array.Exists方法。

Array.IndexOf方法

Array.IndexOf方法用于查找数组中某个元素的索引位置。如果找到了该元素，则返回其索引；如果没有找到，则返回-1。

示例

对于一维数组，可以使用Array.IndexOf方法查找元素的索引：

int[] myArray = { 5, 2, 9, 1, 5, 6 };
int index = Array.IndexOf(myArray, 5);
Console.WriteLine(index); // 输出第一个找到的元素索引

输出结果为：

0

对于多维数组，Array.IndexOf方法不直接适用，因为多维数组的元素是按照行优先顺序存储的。如果需要查找多维数组中的某个元素，可以先将多维数组转换为一维数组，然后进行查找。

例如，查找二维数组中的某个元素：

int[,] matrix = { { 5, 2, 9 }, { 1, 5, 6 }, { 3, 8, 4 } };
int target = 5;
int rows = matrix.GetLength(0);
int cols = matrix.GetLength(1);
int[] flatArray = new int[rows * cols];
int k = 0;

// 将二维数组转换为一维数组
for (int i = 0; i < rows; i++)
{
    for (int j = 0; j < cols; j++)
    {
        flatArray[k++] = matrix[i, j];
    }
}

int index = Array.IndexOf(flatArray, target);
if (index != -1)
{
    int rowIndex = index / cols;
    int colIndex = index % cols;
    Console.WriteLine($"Element {target} found at row {rowIndex}, column {colIndex}");
}
else
{
    Console.WriteLine($"Element {target} not found");
}

输出结果为：

Element 5 found at row 0, column 0

Array.Exists方法

Array.Exists方法用于判断数组中是否存在某个元素。它返回一个布尔值，如果找到该元素则返回true，否则返回false。

示例

对于一维数组，可以使用Array.Exists方法判断是否存在某个元素：

int[] myArray = { 5, 2, 9, 1, 5, 6 };
bool exists = Array.Exists(myArray, element => element == 5);
Console.WriteLine(exists); // 输出是否存在该元素

输出结果为：

True

对于多维数组，同样可以使用Array.Exists方法，但需要先将多维数组转换为一维数组，或者使用嵌套的循环来遍历数组。

例如，判断二维数组中是否存在某个元素：

int[,] matrix = { { 5, 2, 9 }, { 1, 5, 6 }, { 3, 8, 4 } };
int target = 5;
bool exists = false;

for (int i = 0; i < matrix.GetLength(0); i++)
{
    for (int j = 0; j < matrix.GetLength(1); j++)
    {
        if (matrix[i, j] == target)
        {
            exists = true;
            break;
        }
    }
    if (exists)
    {
        break;
    }
}

Console.WriteLine(exists); // 输出是否存在该元素

输出结果为：

True

自定义查找

对于复杂数据类型的数组，可以通过实现Predicate接口来自定义查找逻辑。例如，对于一个Person类的数组，可以根据年龄查找是否存在某个年龄的人：

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Person[] people = { new Person { Name = "Alice", Age = 30 }, new Person { Name = "Bob", Age = 25 }, new Person { Name = "Charlie", Age = 35 } };
bool exists = Array.Exists(people, person => person.Age == 30);
Console.WriteLine(exists); // 输出是否存在该元素

输出结果为：

True

6. 动态数组

6.1 List集合简介

在C#中，`List<T>`是一种动态数组，它提供了比普通数组更灵活的数据结构。与普通数组相比，`List<T>`的大小可以动态变化，这意味着可以在运行时添加或删除元素，而不需要提前指定数组的大小。`List<T>`是`System.Collections.Generic`命名空间中的一个类，它继承自`IList<T>`接口，提供了丰富的操作方法。

`List<T>`的主要特点如下：

• - **动态大小**：`List<T>`可以根据需要自动调整大小，无需在创建时指定固定长度。
• - **类型安全**：`List<T>`是泛型集合，可以指定存储的元素类型，避免了类型转换的错误。
• - **丰富的操作方法**：`List<T>`提供了多种方法，如添加、删除、插入、排序和查找等。

创建`List<T>`的基本语法如下：

using System.Collections.Generic;

List<数据类型> 列表名 = new List<数据类型>();

例如，创建一个存储整数的List：

List<int> myList = new List<int>();

可以使用Add方法向List中添加元素：

myList.Add(1);
myList.Add(2);
myList.Add(3);

List<T>的元素可以通过索引访问，索引从0开始，与普通数组类似：

int firstElement = myList[0]; // 访问第一个元素

6.2 List集合的基本操作

List<T>提供了多种操作方法，以下是一些常用的操作：

添加元素

• Add方法：向List的末尾添加一个元素。

• myList.Add(4);

• Insert方法：在指定的索引位置插入一个元素。

• myList.Insert(1, 10); // 在索引1的位置插入元素10

删除元素

• Remove方法：删除List中的第一个匹配的元素。

• myList.Remove(2); // 删除第一个值为2的元素

• RemoveAt方法：删除指定索引位置的元素。

• myList.RemoveAt(1); // 删除索引为1的元素

清空列表

• Clear方法：清空List中的所有元素。

• myList.Clear();

访问元素

• 通过索引访问：可以直接通过索引访问List中的元素。

• int element = myList[0]; // 访问第一个元素

遍历列表

• foreach循环：遍历List中的所有元素。

• foreach (int element in myList)
  {
      Console.WriteLine(element);
  }

排序

• Sort方法：对List中的元素进行排序，默认为升序。

• myList.Sort();

• 自定义排序：可以通过实现IComparer<T>接口来自定义排序逻辑。

• myList.Sort((x, y) => y.CompareTo(x)); // 降序排序

查找

• IndexOf方法：查找指定元素的索引。

• int index = myList.IndexOf(3); // 查找值为3的元素的索引

• Exists方法：判断List中是否存在某个元素。

• bool exists = myList.Exists(element => element == 3); // 判断是否存在值为3的元素

插入和移除范围

• AddRange方法：向List中添加一个元素集合。

• myList.AddRange(new int[] { 5, 6, 7 });

• RemoveRange方法：从List中移除指定范围的元素。

• myList.RemoveRange(2, 3); // 从索引2开始移除3个元素

List<T>的这些操作方法使其在处理动态数据时比普通数组更加灵活和方便。

7. 总结

在本教程中，我们全面介绍了 C# 中数组的基础知识和使用方法。从数组的基本概念出发，详细讲解了数组的声明、初始化、操作以及遍历方法。通过丰富的示例和详细的代码解析，读者可以快速掌握数组在 C# 程序设计中的应用。

数组作为一种基本的数据结构，在 C# 中具有重要的地位。它不仅可以存储相同类型的元素集合，还能通过索引快速访问和修改数据，极大地提高了程序的效率。无论是简单的一维数组，还是复杂的多维数组和锯齿数组，C# 都提供了灵活的声明和初始化方式，以满足不同场景下的需求。

在数组的操作中，我们重点介绍了如何访问和修改数组元素，以及如何通过循环结构遍历数组。for 循环和 foreach 循环是两种常用的遍历方式，它们各有优势，可以根据具体需求选择使用。此外，数组的常用方法，如排序和查找，也为数据处理提供了强大的支持。

对于动态数据的处理，List<T> 作为一种动态数组，提供了比普通数组更灵活的解决方案。它不仅可以动态调整大小，还具备丰富的操作方法，如添加、删除、插入、排序和查找等。这些特性使得 List<T> 在实际开发中得到了广泛应用。

通过本教程的学习，读者应该能够熟练掌握 C# 中数组的使用方法，并能够将其应用到实际的程序设计中。无论是处理简单的数据集合，还是实现复杂的数据结构，数组和 List<T> 都是 C# 程序设计中不可或缺的工具。希望本教程能够为读者的学习和开发提供有价值的参考。