学习笔记三——数组

1.学习笔记三----关于数组。来自微软的MSDN

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

type[] arrayName;

下面的示例创建一维、多维和交错数组：

C#

class TestArraysClass

{

    static void Main()

    {

        // Declare a single-dimensional array

        int[] array1 = new int[5];

 

        // Declare and set array element values

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

 

        // Alternative syntax

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

 

        // Declare a two dimensional array

        int[,] multiDimensionalArray1 = new int[2, 3];

 

        // Declare and set array element values

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

 

        // Declare a jagged array

        int[][] jaggedArray = new int[6][];

 

        // Set the values of the first array in the jagged array structure

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

    }

}

数组概述

数组具有以下属性：

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

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

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

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

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

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

在 C# 中，数组实际上是对象，而不只是像 C 和 C++ 中那样的可寻址连续内存区域。Array 是所有数组类型的抽象基类型。可以使用 Array 具有的属性以及其他类成员。这种用法的一个示例是使用 Length 属性来获取数组的长度。下面的代码将 numbers 数组的长度（为 5）赋给名为 lengthOfNumbers 的变量：

C#

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

int lengthOfNumbers = numbers.Length;

System.Array 类提供了许多其他有用的方法和属性，用于排序、搜索和复制数组。

 示例

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

C#

class TestArraysClass

{

    static void Main()

    {

        // Declare and initialize an array:

        int[,] theArray = new int[5, 10];

        System.Console.WriteLine("The array has {0} dimensions.", theArray.Rank);

    }

}

 输出

The array has 2 dimensions.

 

2.一维数组（C# 编程指南）

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

C#

int[] array = new int[5];

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

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

C#

string[] stringArray = new string[6];

 数组初始化

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

C#

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

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

C#

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

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

C#

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

string[] weekDays2 = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };

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

C#

int[] array3;

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

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

值类型数组和引用类型数组

请看下列数组声明：

C#

SomeType[] array4 = new SomeType[10];

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

 

3.多维数组（C# 编程指南）

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

C#

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

另外，下列声明创建一个三维（4、2 和 3）数组：

C#

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

数组初始化

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

C#

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

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

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

C#

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

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

C#

int[,] array5;

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

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

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

C#

array5[2, 1] = 25;

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

C#

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

4.交错数组（C# 编程指南）

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

以下示例说明如何声明、初始化和访问交错数组。

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

C#

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

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

C#

jaggedArray[0] = new int[5];

jaggedArray[1] = new int[4];

jaggedArray[2] = new int[2];

每个元素都是一个一维整数数组。第一个元素是由 5 个整数组成的数组，第二个是由 4 个整数组成的数组，而第三个是由 2 个整数组成的数组。

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

C#

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

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

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

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

C#

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

{

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

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

    new int[] {11,22}

};

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

C#

    int[][] jaggedArray3 =

{

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

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

    new int[] {11,22}

};

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

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

C#

// 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;

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

C#

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）：

C#

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

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

C#

System.Console.WriteLine(jaggedArray4.Length);

将返回值 3。

 示例

本例生成一个数组，该数组的元素为数组自身。每一个数组元素都有不同的大小。

C#

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();

        }

    }

}

 输出

Element(0): 1 3 5 7 9

Element(1): 2 4 6 8

 

5对数组使用 foreach（C# 编程指南）

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

C#

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

foreach (int i in numbers)

{

    System.Console.WriteLine(i);

}

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

C#

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

foreach (int i in numbers2D)

{

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

}

该示例的输出为：

9 99 3 33 5 55

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

 

6.将数组作为参数传递（C# 编程指南）

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

将一维数组作为参数传递

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

C#

PrintArray(theArray);

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

C#

void PrintArray(int[] arr)

{

    // method code

}

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

C#

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

 示例 1

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

C#

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);

    }

}

 输出 1

Sun Mon Tue Wed Thu Fri Sat

 将多维数组作为参数传递

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

C#

PrintArray(theArray);

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

C#

void PrintArray(int[,] arr)

{

    // method code

}

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

C#

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

 示例 2

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

C#

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 } });

    }

}

 输出 2

Element(0,0)=1

Element(0,1)=2

Element(1,0)=3

Element(1,1)=4

Element(2,0)=5

Element(2,1)=6

Element(3,0)=7

Element(3,1)=8

7.使用 ref 和 out 传递数组（C# 编程指南）

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

例如：

C#

static void TestMethod1(out int[] arr)

{

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

}

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

C#

static void TestMethod2(ref int[] arr)

{

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

}

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

 示例 1

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

C#

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] + " ");

        }

    }

}

 输出 1

Array elements are:

1 2 3 4 5

 示例 2

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

C#

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] + " ");

        }

    }

}

 输出 2

Array elements are:

1111 2 3 4 5555