C#数组

数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合。所有的数组都是由连续的内存位置组成的。

声明数组

在 C# 中声明一个数组，您可以使用下面的语法：

datatype[] arrayName;

例如：

double[] balance;

初始化数组

声明一个数组不会在内存中初始化数组。当初始化数组变量时，您可以赋值给数组。

数组是一个引用类型，所以您需要使用 new 关键字来创建数组的实例。

例如：

double[] balance = new double[10];

赋值给数组

您可以通过使用索引号赋值给一个单独的数组元素，比如：

double[] balance = new double[10];
balance[0] = 4500.0;

您可以在声明数组的同时给数组赋值，比如：

double[] balance = { 2340.0, 4523.69, 3421.0};

您也可以创建并初始化一个数组，比如：

int [] marks = new int[5]  { 99,  98, 92, 97, 95};

在上述情况下，你也可以省略数组的大小，比如：

int [] marks = new int[]  { 99,  98, 92, 97, 95};

您也可以赋值一个数组变量到另一个目标数组变量中。在这种情况下，目标和源会指向相同的内存位置：

int [] marks = new int[]  { 99,  98, 92, 97, 95};
int[] score = marks;

当您创建一个数组时，C# 编译器会根据数组类型隐式初始化每个数组元素为一个默认值。例如，int 数组的所有元素都会被初始化为 0。

访问数组元素

元素是通过带索引的数组名称来访问的。这是通过把元素的索引放置在数组名称后的方括号中来实现的。例如：

double salary = balance[9];

下面是一个实例，使用上面提到的三个概念，即声明、赋值、访问数组：

[csharp]  view plain  copy

1. using System;  
2. namespace ArrayApplication  
3. {  
4.    class MyArray  
5.    {  
6.       static void Main(string[] args)  
7.       {  
8.          int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */  
9.          int i,j;  
10.   
11.   
12.          /* 初始化数组 n 中的元素 */           
13.          for ( i = 0; i < 10; i++ )  
14.          {  
15.             n[ i ] = i + 100;  
16.          }  
17.   
18.          /* 输出每个数组元素的值 */  
19.          for (j = 0; j < 10; j++ )  
20.          {  
21.             Console.WriteLine("Element[{0}] = {1}", j, n[j]);  
22.          }  
23.          Console.ReadKey();  
24.       }  
25.    }  
26. }  

当上面的代码被编译和执行时，它会产生下列结果：

[csharp]  view plain  copy

1. Element[0] = 100  
2. Element[1] = 101  
3. Element[2] = 102  
4. Element[3] = 103  
5. Element[4] = 104  
6. Element[5] = 105  
7. Element[6] = 106  
8. Element[7] = 107  
9. Element[8] = 108  
10. Element[9] = 109  

使用 foreach 循环

在前面的实例中，我们使用一个 for 循环来访问每个数组元素。您也可以使用一个 foreach 语句来遍历数组。

[csharp]  view plain  copy

1. using System;  
2.   
3. namespace ArrayApplication  
4. {  
5.    class MyArray  
6.    {  
7.       static void Main(string[] args)  
8.       {  
9.          int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */  
10.   
11.   
12.          /* 初始化数组 n 中的元素 */           
13.          for ( int i = 0; i < 10; i++ )  
14.          {  
15.             n[i] = i + 100;  
16.          }  
17.   
18.          /* 输出每个数组元素的值 */  
19.          foreach (int j in n )  
20.          {  
21.             int i = j-100;  
22.             Console.WriteLine("Element[{0}] = {1}", i, j);  
23.          }  
24.          Console.ReadKey();  
25.       }  
26.    }  
27. }  

当上面的代码被编译和执行时，它会产生下列结果：

[csharp]  view plain  copy

1. Element[0] = 100  
2. Element[1] = 101  
3. Element[2] = 102  
4. Element[3] = 103  
5. Element[4] = 104  
6. Element[5] = 105  
7. Element[6] = 106  
8. Element[7] = 107  
9. Element[8] = 108  
10. Element[9] = 109  

多维数组

您可以声明一个 string 变量的二维数组，如下：

string [,] names;

或者，您可以声明一个 int 变量的三维数组，如下：

int [ , , ] m;

二维数组

多维数组最简单的形式是二维数组。一个二维数组，在本质上，是一个一维数组的列表。

一个二维数组可以被认为是一个带有 x 行和 y 列的表格。下面是一个二维数组，包含 3 行和 4 列：

因此，数组中的每个元素是使用形式为 a[ i , j ] 的元素名称来标识的，其中 a 是数组名称，i 和 j 是唯一标识 a 中每个元素的下标。

初始化二维数组

多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。

int [,] a = new int [3,4] {
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

访问二维数组元素

二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的。例如：

int val = a[2,3];

上面的语句将获取数组中第 3 行第 4 个元素。您可以通过上面的示意图来进行验证。让我们来看看下面的程序，我们将使用嵌套循环来处理二维数组：

[csharp]  view plain  copy

1. using System;  
2.   
3. namespace ArrayApplication  
4. {  
5.     class MyArray  
6.     {  
7.         static void Main(string[] args)  
8.         {  
9.             /* 一个带有 5 行 2 列的数组 */  
10.             int[,] a = new int[5, 2] {{0,0}, {1,2}, {2,4}, {3,6}, {4,8} };  
11.   
12.             int i, j;  
13.   
14.             /* 输出数组中每个元素的值 */  
15.             for (i = 0; i < 5; i++)  
16.             {  
17.                 for (j = 0; j < 2; j++)  
18.                 {  
19.                     Console.WriteLine("a[{0},{1}] = {2}", i, j, a[i,j]);  
20.                 }  
21.             }  
22.            Console.ReadKey();  
23.         }  
24.     }  
25. }  

当上面的代码被编译和执行时，它会产生下列结果：

[csharp]  view plain  copy

1. a[0,0]: 0  
2. a[0,1]: 0  
3. a[1,0]: 1  
4. a[1,1]: 2  
5. a[2,0]: 2  
6. a[2,1]: 4  
7. a[3,0]: 3  
8. a[3,1]: 6  
9. a[4,0]: 4  
10. a[4,1]: 8  

数组的数组

数组的数组也叫交错数组。您可以声明一个带有 int 值的交错数组 scores，如下所示：

int [][] scores;

声明一个数组不会在内存中创建数组。创建上面的数组：

int[][] scores = new int[5][];
for (int i = 0; i < scores.Length; i++) 
{
   scores[i] = new int[4];
}

您可以初始化一个交错数组，如下所示：

int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};

其中，scores 是一个由两个整型数组组成的数组 -- scores[0] 是一个带有 3 个整数的数组，scores[1] 是一个带有 4 个整数的数组。

下面的实例演示了如何使用交错数组：

[csharp]  view plain  copy

1. using System;  
2.   
3. namespace ArrayApplication  
4. {  
5.     class MyArray  
6.     {  
7.         static void Main(string[] args)  
8.         {  
9.             /* 一个由 5 个整型数组组成的交错数组 */  
10.             int[][] a = new int[][]{new int[]{0,0},new int[]{1,2},   
11.             new int[]{2,4},new int[]{ 3, 6 }, new int[]{ 4, 8 } };   
12.   
13.             int i, j;  
14.   
15.             /* 输出数组中每个元素的值 */  
16.             for (i = 0; i < 5; i++)  
17.             {  
18.                 for (j = 0; j < 2; j++)  
19.                 {  
20.                     Console.WriteLine("a[{0}][{1}] = {2}", i, j, a[i][j]);  
21.                 }  
22.             }  
23.            Console.ReadKey();  
24.         }  
25.     }  
26. }  

当上面的代码被编译和执行时，它会产生下列结果：

[csharp]  view plain  copy

1. a[0][0] = 0  
2. a[0][1] = 0  
3. a[1][0] = 1  
4. a[1][1] = 2  
5. a[2][0] = 2  
6. a[2][1] = 4  
7. a[3][0] = 3  
8. a[3][1] = 6  
9. a[4][0] = 4  
10. a[4][1] = 8  

参数数组

有时，当声明一个方法时，您不能确定要传递给函数作为参数的参数数目。C# 参数数组解决了这个问题，参数数组通常用于传递未知数量的参数给函数。

params 关键字

在使用数组作为形参时，C# 提供了 params 关键字，使调用数组为形参的方法时，既可以传递数组实参，也可以只传递一组数组。params 的使用格式为：

public 返回类型 方法名称( params 类型名称[] 数组名称 )

[csharp]  view plain  copy

1. using System;  
2.   
3. namespace ArrayApplication  
4. {  
5.    class ParamArray  
6.    {  
7.       public int AddElements(params int[] arr)  
8.       {  
9.          int sum = 0;  
10.          foreach (int i in arr)  
11.          {  
12.             sum += i;  
13.          }  
14.          return sum;  
15.       }  
16.    }  
17.         
18.    class TestClass  
19.    {  
20.       static void Main(string[] args)  
21.       {  
22.          ParamArray app = new ParamArray();  
23.             
24.          int[] arr = {512, 720, 250, 567, 889};  
25.          int sum1 = app.AddElements(arr);  
26.          //以上2行可以使用下面一行代替  
27.          int sum2 = app.AddElements(512, 720, 250, 567, 889);  
28.             
29.          Console.WriteLine("总和是： {0}", sum1);   
30.          Console.WriteLine("总和是： {0}", sum2);  
31.          Console.ReadKey();  
32.       }  
33.    }  
34. }  

当上面的代码被编译和执行时，它会产生下列结果：

总和是：2938
总和是：2938

Array类

Array 类是 C# 中所有数组的基类，它是在 System 命名空间中定义。Array 类提供了各种用于数组的属性和方法。

下表列出了 Array 类中一些最常用的属性：

序号	属性 & 描述
1	IsFixedSize 获取一个值，该值指示数组是否带有固定大小。
2	IsReadOnly 获取一个值，该值指示数组是否只读。
3	Length 获取一个 32 位整数，该值表示所有维度的数组中的元素总数。
4	LongLength 获取一个 64 位整数，该值表示所有维度的数组中的元素总数。
5	Rank 获取数组的秩（维度）。

如需了解 Array 类的完整的属性列表，请参阅微软的 C# 文档。

Array方法

下表列出了 Array 类中一些最常用的方法：

序号	方法 & 描述
1	Clear 根据元素的类型，设置数组中某个范围的元素为零、为 false 或者为 null。
2	Copy(Array, Array, Int32) 从数组的第一个元素开始复制某个范围的元素到另一个数组的第一个元素位置。长度由一个 32 位整数指定。
3	CopyTo(Array, Int32) 从当前的一维数组中复制所有的元素到一个指定的一维数组的指定索引位置。索引由一个 32 位整数指定。
4	GetLength  获取一个 32 位整数，该值表示指定维度的数组中的元素总数。
5	GetLongLength 获取一个 64 位整数，该值表示指定维度的数组中的元素总数。
6	GetLowerBound 获取数组中指定维度的下界。
7	GetType 获取当前实例的类型。从对象（Object）继承。
8	GetUpperBound 获取数组中指定维度的上界。
9	GetValue(Int32) 获取一维数组中指定位置的值。索引由一个 32 位整数指定。
10	IndexOf(Array, Object) 搜索指定的对象，返回整个一维数组中第一次出现的索引。
11	Reverse(Array) 逆转整个一维数组中元素的顺序。
12	SetValue(Object, Int32) 给一维数组中指定位置的元素设置值。索引由一个 32 位整数指定。
13	Sort(Array) 使用数组的每个元素的 IComparable 实现来排序整个一维数组中的元素。
14	ToString 返回一个表示当前对象的字符串。从对象（Object）继承。

如需了解 Array 类的完整的方法列表，请参阅微软的 C# 文档。

下面的程序演示了 Array 类的一些方法的用法：

[csharp]  view plain  copy

1. using System;  
2. namespace ArrayApplication  
3. {  
4.     class MyArray  
5.     {  
6.           
7.         static void Main(string[] args)  
8.         {  
9.             int[] list = { 34, 72, 13, 44, 25, 30, 10 };  
10.             int[] temp = list;  
11.   
12.             Console.Write("原始数组： ");  
13.             foreach (int i in list)  
14.             {  
15.                 Console.Write(i + " ");  
16.             }  
17.             Console.WriteLine();  
18.              
19.             // 逆转数组  
20.             Array.Reverse(temp);  
21.             Console.Write("逆转数组： ");  
22.             foreach (int i in temp)  
23.             {  
24.                 Console.Write(i + " ");  
25.             }  
26.             Console.WriteLine();  
27.               
28.             // 排序数组  
29.             Array.Sort(list);  
30.             Console.Write("排序数组： ");  
31.             foreach (int i in list)  
32.             {  
33.                 Console.Write(i + " ");  
34.             }  
35.             Console.WriteLine();  
36.   
37.            Console.ReadKey();  
38.         }  
39.     }  
40. }  

当上面的代码被编译和执行时，它会产生下列结果：

[csharp]  view plain  copy

1. 原始数组： 34 72 13 44 25 30 10  
2. 逆转数组： 10 30 25 44 13 72 34  
3. 排序数组： 10 13 25 30 34 44 72