【一文了解】C#基础-数组

最新推荐文章于 2025-05-08 16:51:17 发布

yi碗汤园

最新推荐文章于 2025-05-08 16:51:17 发布

阅读量1.8k

点赞数 10

分类专栏： C# 文章标签： c# 开发语言前端 unity

本文链接：https://blog.youkuaiyun.com/grapefruit_lyy/article/details/143884897

版权

C# 专栏收录该内容

25 篇文章

订阅专栏

4.2 使用 foreach 循环遍历数组

本篇文章来学习一下数组，从声明、初始化、访问、遍历等方面来了解数组，通过学习多维数组、锯齿/交错数组、参数数组加深对数组的理解。

在C#中，数组是一个存储固定大小、相同类型数据的集合。数组的元素是按顺序排列的，可以通过索引来访问和修改。数组在C#中是引用类型，创建后数组的大小是固定的。

数组

1.声明和初始化

数组的声明和初始化可以在同一行完成。

1.1 声明数组

声明数组时，你需要指定数组的类型和数组名。数组类型可以是任何数据类型（如int、string、double等）。

int[] numbers;//声明一个整数类型的数组

1.2 初始化数组

数组的初始化可以通过两种方式：

1）使用new关键字并指定数组大小。

2）直接使用大括号{}来初始化数组元素。

//1)通过new初始化：
numbers = new int[5];//创建一个包含5个整数的数组，元素默认为 0
//numbers = new int[5]{ 1, 2, 3, 4, 5 };

//2)直接初始化数组：
numbers = { 1, 2, 3, 4, 5 };

2. 数组的访问

数组中的元素可以通过索引访问，索引从0开始。

int firstNumber = numbers[0];//访问数组的第一个元素，值为 1
numbers[1] = 10;//将数组第二个元素的值修改为 10

3. 数组的长度

数组的长度可以通过Length属性来获取，表示数组中元素的数量。

int length = numbers.Length;//获取数组的长度，返回 5

4. 数组的遍历

C#中常用的数组遍历方式有 for 循环和 foreach 循环。

4.1 使用 for 循环遍历数组

for (int i = 0; i < numbers.Length; i++)
{
    Debug.Log(numbers[i]);
}

4.2 使用 foreach 循环遍历数组

foreach (int number in numbers)
{
    Debug.Log(number);
}

5. 数组的常用操作

C#提供了一些数组的实用方法来操作数组。

5.1 数组排序（Array.Sort）

Array.Sort(numbers);//对数组进行升序排序

5.2 数组反转（Array.Reverse）

Array.Reverse(numbers);//反转数组

5.3 数组复制（Array.Copy）

int[] copy = new int[5];
Array.Copy(numbers, copy, numbers.Length);//将 numbers 数组的内容复制到 copy 数组

6. 数组的特性

1）固定大小：数组在初始化时需要指定大小，一旦创建，大小无法更改。

2）元素类型相同：数组中的所有元素必须是相同类型。

3）零索引：数组的索引从 0 开始，最后一个元素的索引为 Length - 1。

7. 数组分类

7.1多维数组

多维数组包括二维数组、三维数组等。

1）二维数组

二维数组可以视为一个矩阵，具有行和列。

int[,] matrix = new int[2, 3];//创建一个 2 行 3 列的二维数组
matrix[0, 0] = 1;//第一行第一列
matrix[1, 2] = 5;//第二行第三列
也可以通过直接初始化二维数组：
int[,] matrix = { {1, 2, 3}, {4, 5, 6} };//初始化一个 2 行 3 列的二维数组

2）三维数组

三维数组是包含多个二维数组的数组。

int[,,] array3D = new int[2, 3, 4];//2 个二维数组，每个二维数组 3 行 4 列

7.2锯齿/交错数组

锯齿数组，也称交错数组，即数组中的每个元素本身可以是一个数组，因此每个子数组的大小可以不同，这也就是它们被称为“交错”的原因。这使得锯齿数组具有灵活性和不规则性，通常用于存储具有不同长度的数据集合。是一种特殊的多维数组。

特点：

1）不规则的行列结构：每一行（即每个子数组）可以有不同数量的元素，类似于一个交错的矩阵。

2）数组元素本身是数组：是一个数组的数组，可以通过new关键字创建一个包含子数组的数组。

int[][] jaggedArray = new int[2][];//创建一个有 2 个元素的锯齿数组
jaggedArray[0] = new int[3];//第一行有 3 个元素
jaggedArray[1] = new int[2];//第二行有 2 个元素

jaggedArray[0][0] = 1;//第一行的第一个元素
jaggedArray[0][1] = 2;
jaggedArray[0][2] = 3;

jaggedArray[1][0] = 4;
jaggedArray[1][1] = 5;//第二行的第二个元素

for (int i = 0; i < jaggedArray.Length; i++)
{
    for (int j = 0; j < jaggedArray[i].Length; j++)
    {
        Debug.Log(jaggedArray[i][j]);//打印每个元素
    }
}


foreach (var row in jaggedArray)
{
    foreach (var item in row)
    {
        Debug.Log(item);//打印每个元素
    }
}

7.3参数数组

使用params关键字定义一个可变参数数组，允许在调用方法时传递任意数量的参数。使用 params时，可以向方法传递一个数组，或者直接传递多个值，编译器会自动将它们转换为数组。params参数使得方法更加灵活，不需要提前指定固定数量的参数。这对于处理动态数量的输入参数非常有用。

1）params

①基本语法

params关键字只能用于方法的最后一个参数，并且该参数必须是一个数组类型。表示可以传入一个数组，或者直接传入多个参数。

在下面的代码中，numbers是一个 int[]类型的数组，但它使用params关键字定义，表示可以传入任意数量的int参数。

public void MyMethod(params int[] numbers)
{
    foreach (var number in numbers)
    {
        Debug.Log(number);
    }
}

②如何使用

可以在调用方法时传递一个数组，也可以直接传递多个值。C#会自动将传递的多个值转换成一个数组。

//直接传递多个值：
MyMethod(1, 2, 3, 4, 5);//等同于MyMethod(new int[] { 1, 2, 3, 4, 5 })
//传递数组：
int[] numbers = { 1, 2, 3, 4, 5 };
MyMethod(numbers);//也可以直接传入数组
//不传递参数：
MyMethod();//也可以不传递任何参数，这时数组长度为 0

③规则

params必须是方法参数列表中的最后一个参数。可以传递一个数组，或者传递多个单独的参数。C#会自动把多个单独的参数转换成数组。params只能用在方法定义中一次，方法的其他参数不能再使用params关键字。

2）举例

实现求和方法，假设需要一个方法来计算传入的任意数量的数字的总和。此时使用params可以非常方便地实现这一点。

public int Sum(params int[] numbers)
{
    int sum = 0;
    foreach (int number in numbers)
    {
        sum += number;
    }
    return sum;
}

//调用该方法并传递任意数量的参数：
Debug.Log(Sum(1, 2, 3));//输出 6
Debug.Log(Sum(10, 20, 30, 40));//输出 100
Debug.Log(Sum());//输出 0 (没有传递参数)

3）params与数组的区别

虽然params看起来是一个数组，但它允许在调用方法时直接传递单独的参数，而不必显式创建一个数组。如：

MyMethod(1, 2, 3, 4);//编译器会自动将其转为 new int[] {1, 2, 3, 4}

如果没有params，则必须显式传递一个数组：

MyMethod(new int[] { 1, 2, 3, 4 });

4）params 和多重参数类型

params 参数可以接受不同类型的数组，通常是类型一致的数组。例如，params int[]只能接收int类型的参数，如果尝试传递其他类型的参数，编译器会报错。

但是，params不支持同时处理多个类型的参数。例如，不能在一个方法中同时接受params int[]和params string[]，因为它们都需要是方法的最后一个参数。

5）params 与方法重载

当使用params时，可以减少方法重载的需要。如，需要编写一个方法来处理不同数量的参数，通过params可以避免编写多个重载版本。

public void Print(int a)
{
    Debug.Log(a);
}
public void Print(int a, int b)
{
    Debug.Log(a + ", " + b);
}
public void Print(int a, int b, int c)
{
    Debug.Log(a + ", " + b + ", " + c);
}


public void Print(params int[] values)
{
    foreach (var value in values)
    {
        Debug.Log(value);
    }
}

好了，本次的分享到这里就结束啦，希望对你有所帮助~