数组

数组

数组是一种数据结构，它包含若干相同类型的变量。数组是使用类型声明的：

type[] arrayName;

 

数组概述

数组具有以下属性：

l         数组可以是一维、多维或交错的

l         数值数组元素的默认值设置为零，而引用元素的默认值设置为null

l         交错数组是数组的数组，因此，它的元素是引用类型，初始化为null

l         数组的索引从零开始：具有n个元素的数组的索引是从0到n-1

l         数组元素可以是任何类型，包括数组类型

l         数组类型是从抽象基类型Array派生的引用类型。由于此类型实现了IEnumerable，因此可以对C#中的所有数组使用foreach迭代

 

作为对象的数组

在C#中，数组实际上是对象，而不只是像C和C++中那样的可寻址连续内存区域。Array是所有数组类型的抽象基类型。可以使用Array具有的属性以及其他类成员。

示例：此示例使用Rank属性来显示数组的维数

class TestArrayClass...{
        static void Main()...{
                //Declare and initialize an array:
                int[,] theArray = new int[5,10];
                System.Console.WriteLine("The array has {0} dimensions.",theArray.Rank);
            }
    }

 

一维数组

可以如下例所示声明一个由5个整数组成的数组：

int[] array = new int[5];

此数组包含从array[0]到array[4]的元素。New运算符用于创建数组并将数组元素初始化为它们的默认值。在此例中，所有数组元素都初始化为零。

可以用相同的方式声明存储字符串元素的数组。例如：

string[] stringArray = new string[6];

 

数组初始化

可以在声明数组时将其初始化，在这种情况下不需要级别说明符，因为级别说明符已经由初始化表中的元素数提供。例如：

int[] array = new int[5] {1,3,5,7,9};

可以用相同的方式初始化字符串数组。下面声明一个字符串数组，其中每个数组元素用每天的名称初始化：

string[] weekDays = new string[] {“Sun”,”Mon”,”Tue”,”Wed”,”Thu”,”Fri”,”Sat”};

如果在声明数组时将其初始化，则可以使用下列快捷方式：

int[] array = {1,3,5,7,9};

string[] weekDays = {“Sun”,”Mon”,”Tue”,”Wed”,”Thu”,”Fri”,”Sat”};

可以声明一个数组变量但不将其初始化，但在将数组分配给此变量时必须使用new运算符。例如：

int[] array;

array = new int[] {1,3,5,7,9};              //OK

//array = {1,3,5,7,9};            //Error

 

值类型和引用类型数组

请看下列数组声明：

SomeType[] array = new SomeType[10];

该语句的结果取决于SomeType是值类型还是引用类型。如果是值类型，则该语句将创建一个由10个SomeType类型的实例组成的数组。如果SomeType是引用类型，则该语句将创建一个由10个元素组成的数组，其中每个元素都初始化为空引用。

 

多维数组

数组可以具有多个维度。例如，下列声明创建一个四行两列的二维数组：

int[,] array = new int[4, 2];

另外，下列声明创建一个三维(4,2和3)数组：

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

 

数组初始化

可以在声明数组时将其初始化，如下例所示：

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

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

也可以初始化数组但不制定级别：

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

如果选择声明一个数组变量但不将其初始化，必须使用new运算符将一个数组分配给此变量。例如：

int[,] array5;

array5 = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };   // OK

//array5 = {{1,2}, {3,4}, {5,6}, {7,8}};   // Error

也可以给数组元素赋值，例如：

array5[2, 1] = 25;

 

下面的代码示例将数组变量初始化为默认值(交错数组除外)：

int[,] array6 = new int[10, 10];

 

交错数组

交错数组是元素为数组的数组。交错数组元素的维度和大小可以不同。交错数组有时称为“数组的数组”。

下面声明一个由三个元素组成的一维数组，其中每个元素都是一个一维整数数组：

int[][] jaggedArray = new int[3][];

必须初始化jaggedArray的元素后才可以使用它。可以如下例初始化该元素：

jaggedArray[0] = new int[5];

jaggedArray[1] = new int[4];

jaggedArray[2] = new int[2];

也可以使用初始值设定项用值充数组元素，在这种情况下不需要数组大小。例如：

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

jaggedArray[1] = new int[] { 0, 2, 4, 6 };

jaggedArray[2] = new int[] { 11, 22 };

还可以在声明数组时将其初始化，如：

int[][] jaggedArray2 = new int[][]

{

    new int[] {1,3,5,7,9},

    new int[] {0,2,4,6},

    new int[] {11,22}

};

可以使用下面的速记格式。请注意：不能从元素初始化中省略new运算符，因为不存在元素的默认初始化：

int[][] jaggedArray3 =

{

    new int[] {1,3,5,7,9},

    new int[] {0,2,4,6},

    new int[] {11,22}

};

交错数组是数组的数组，因此其元素是引用类型并初始化为null。

可以如下例所示访问个别数组元素：

// Assign 77 to the second element ([1]) of the first array ([0]):

jaggedArray3[0][1] = 77;

 

// Assign 88 to the second element ([1]) of the third array ([2]):

jaggedArray3[2][1] = 88;

可以混合使用交错数组和多维数组。下面声明和初始化一个一维交错数组，该数组包含大小不同的二维数组元素：

int[][,] jaggedArray4 = new int[3][,]

{

    new int[,] { {1,3}, {5,7} },

    new int[,] { {0,2}, {4,6}, {8,10} },

    new int[,] { {11,22}, {99,88}, {0,9} }

};

可以如本例所示访问个别元素，该示例第一个数组的元素[1,0]的值(值为5)：

System.Console.Write("{0}", jaggedArray4[0][1, 0]);

方法Length返回包含的交错数组中的数组的数目。例如,假定您已声明了前一个数组，则此行：

System.Console.WriteLine(jaggedArray4.Length);

将返回值3

class ArrayTest...{
        static void Main()...{
                //Declare the array of two elements:
                int[][] arr = new int[2][];
                //Initialize the elements:
                arr[0] = new int[5] ...{1,3,5,7,9};
                arr[1] = new int[4] ...{2,4,6,8};
                
                //Display the array elements:
                for (int i = 0; i < arr.Length; i++)...{
                        System.Console.Write("Element({0}):",i);
                        for (int j = 0; j < arr[i].Length; j++)...{
                                System.Console.Write("{0}{1}",arr[i][j],j == (arr[i].Length - 1) ? "" : " ");
                            }
                        System.Console.WriteLine();
                    }
            }
    }

对数组使用foreach

C#还提供foreach语句。该语句提供一种简单、明了的方法来循环访问数组的元素。例如，下面的代码创建一个名为numbers的数组，并用foreach语句循环访问该数组：

int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };

foreach (int i in numbers)

{

    System.Console.WriteLine(i);

}

由于有个多维数组，可以使用相同方法来循环访问元素，例如：

int[,] numbers2D = new int[3, 2] { { 9, 99 }, { 3, 33 }, { 5, 55 } };

foreach (int i in numbers2D)

{

    System.Console.Write("{0} ", i);

}

对于多维数组，使用嵌套的for循环可以更好地控制数组元素。

 

将数组作为参数传递

数组可作为参数传递给方法。因为数组是引用类型，所以方法可以更改元素的值。

将一维数组作为参数传递

可以将初始化的一维数组传递给方法。例如：

PrintArray(theArray);

上面的行中调用的方法可定义为：

void PrintArray(int[] arr)

{

    // method code

}

也可以在一个步骤中初始化并传递新数组。例如：

PrintArray(new int[] { 1, 3, 5, 7, 9 });

在下例中，初始化一个字符串数组并将其作为参数传递给PrintArray方法(该数组的元素显示在此方法中)：

class ArrayClass...{
        static void PrintArray(string[] arr)...{
                for (int i = 0; i < arr.Length; i++)...{
                        System.Console.Write(arr[i] + "{0}", i < arr.Length - 1 ? " ":"");
                    }
                System.Console.WriteLine();
            }
        
        static void Main()...{
                //Declare and initialize an array:
                string[] weekDays = new string[]...{"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
                //Pass the array as a parameter:
                PrintArray(weekDays);
            }
    }

将多维数组作为参数传递

可以将初始化的多维数组传递给方法。例如，如果theArray是二维数组：

PrintArray(theArray);

上面的行中调用的方法可定义为：

void PrintArray(int[,] arr)

{

    // method code

}

也可以在一个步骤中初始化并传递新数组。例如：

PrintArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });

在此示例中，初始化一个二维数组并将其传递给PrintArray方法(该数组的元素显示在此方法中)。

class ArrayClass2D...{
        static void PrintArray(int[,] arr)...{
                //Display the array elements:
                for (int i = 0; i < 4; i++)...{
                        for (int j = 0; j < 2; j++)...{
                                System.Console.WriteLine("Element({0},{1})={2}",i,j,arr[i,j]);
                            }
                    }
            }
        
        static void Main()...{
                //Pass the array as a parameter:
                PrintArray(new int[,]...{...{1,2},...{3,4},...{5,6},...{7,8}});
            }
    }

使用ref和out传递数组

与所有的out参数一样，在使用数组类型的out参数前必须先为其赋值，即必须由被调用方为其赋值。例如：

static void TestMethod1(out int[] arr)

{

    arr = new int[10];   // definite assignment of arr

}

与所有的ref参数一样，数组类型的ref参数必须由调用方明确赋值。因此不需要由接受方明确赋值。可以将数组类型的ref参数更改为调用的结果。例如，可以为数组赋以null值，或将其初始化为另一个数组。例如：

static void TestMethod2(ref int[] arr)

{

    arr = new int[10];   // arr initialized to a different array

}

下面的两个示例说明out与ref在将数组传递给方法时的用法差异。

在此例中，在调用方(Main方法)中声明数组theArray，并在FillArray方法中初始化此数组。然后将数组元素返回调用方并显示。

class TestOut...{
        static void FillArray(out int[] arr)...{
                //Initialize the array:
                arr = new int[5]...{1,2,3,4,5};
            }
        
        static void Main()...{
                int[] theArray;//Initialization is not required
                
                //Pass the array to the callee using out:
                FillArray(out theArray);
                
                //Display the array elements:
                System.Console.WriteLine("Array elements are:");
                for (int i = 0; i < theArray.Length; i++)...{
                        System.Console.Write(theArray[i] + " ");
                    }
            }
    }

在此例中，在调用方(Main方法)中初始化数组theArray，并通过使用ref参数将其传递给FillArray方法。在FillArray方法中更新某些数组元素。然后将数组元素返回调用方并显示。

class TestRef...{
        static void FillArray(ref int[] arr)...{
                //Create the array on demand:
                if (arr == null)...{
                        arr = new int[10];
                    }
                //Fill the array:
                arr[0] = 1111;
                arr[4] = 5555;
            }
        
        static void Main()...{
                //Initialize the array:
                int[] theArray = ...{1,2,3,4,5};
                //Pass the array using ref:
                FillArray(ref theArray);
                //Display the updated array:
                System.Console.WriteLine("Array elements are:");
                for (int i = 0; i < theArray.Length; i++)...{
                        System.Console.Write(theArray[i] + " ");
                    }
            }
    }