C#基础知识整理：基础知识（14） 数组

无论哪种语言，肯定会有集合的概念。而最简单，最直观的集合应该就是数组了，数组是在内存中连续的一段空间。看看C#中数组

的定义。
1、int[] intArry ;
 intArry= new int[6];
 这里声明了一个int数组类型变量intArry，并保存一个具有6个单元的int数组对象；
 int[,] intArry2 = new int[3, 4];
 声明一个int二维数组类型变量，并初始化一个3行4列的数组对象；
 int[][] intArry3 = new int[9][];
 声明一个数组单元为int数组类型的数组变量，每个数组元素是一个int数组类型的对象引用。
 因为是面向对象语言，上面提到了引用和对象。其实：
 1、.net Frameword数组不是一种单纯的数据结构，而是一个类型，叫数组类型；
 2、.net Framework中的数组变量保存着引用到数组类型对象的引用，也就是说数组是一个对象。
所有.net Framework数组(int[],string[],object[])都是从Array继承的子类。一般不直接使用Array类，因为.net Framework下

的各类语言，当然也包括C#，将数组对象映射为各自的特殊语法了，比如int[],string[]。
数组主要有两个各属性：索引和长度，也就是index和length，索引用于访问数组对象中的元素，长度也就是数组的长度。
看一段联系代码：

[csharp] view plain copy print ?

1. public class MyArray  
2.     {  
3.         /// <summary>   
4.         /// 定义数组测试   
5.         /// </summary>   
6.         public void TestInt()  
7.         {  
8.             int[] intArry1 = null;  
9.   
10.             intArry1 = new int[6];  
11.   
12.             int[,] intArry2 = new int[3, 4];  
13.   
14.             int[][] intArry3 = new int[9][];  
15.         }  
16.           
17.         /// <summary>   
18.         /// 值类型数组转引用类型数组测试   
19.         /// </summary>   
20.         /// <param name="array"></param>   
21.         /// <returns></returns>  
22.         public static object[] Int32ToArrayOfObject(int[] array)  
23.         {  
24.             object[] objArray = new object[array.Length];  
25.   
26.             for (int i = 0; i < array.Length; i++)  
27.             {  
28.                 objArray[i] = array[i];  
29.             }  
30.   
31.             return objArray;  
32.         }  
33.         /// <summary>   
34.         /// 数组的主要特性测试   
35.         /// </summary>   
36.         public static void MainTest()  
37.         {  
38.             //声明一个包含是个元素的字符串型数组   
39.             string[] sArray = new string[10];  
40.             //访问数组   
41.             //赋值   
42.             for (int i = 0; i < sArray.Length; i++)  
43.             {  
44.                 sArray[i] = @"string" + i;  
45.             }  
46.   
47.             ConsoleToClientString(sArray);  
48.   
49.             //另一种方式声明数组，所谓的枚举法  
50.             sArray = new string[] { "TestString0", "TestString1", "TestString2" };  
51.   
52.             ConsoleToClientString(sArray);  
53.   
54.             //数组复制   
55.             string[] newSArray = sArray.Clone() as string[];  
56.   
57.             ConsoleToClientString(newSArray);  
58.   
59.             //使用Array的CreateInstance方法声明10元素的整形数组  
60.             int[] intArray = Array.CreateInstance(typeof(int), 10) as int[];  
61.   
62.             for (int i = 0; i < intArray.Length; i++)  
63.             {  
64.                 intArray[i] = i;  
65.             }  
66.   
67.             ConsoleToClientInt(intArray);  
68.   
69.             //数组之间的复制，指定位置，指定长度  
70.             int[] newIntArray = new int[20];  
71.   
72.             Array.Copy(intArray, 3, newIntArray, 4, intArray.Length - 3);  
73.   
74.             ConsoleToClientInt(newIntArray);  
75.   
76.             object[] objArray = sArray;  
77.   
78.             ConsoleToClientObject(objArray);  
79.   
80.             objArray = Int32ToArrayOfObject(intArray);  
81.   
82.             ConsoleToClientObject(objArray);  
83.   
84.             //数组的数组   
85.             int[][] intArrayArray = new int[9][];  
86.   
87.             Console.WriteLine("数组长度：" + intArrayArray.Length);  
88.   
89.             //赋值   
90.             for (int i = 1; i < 10; i++)  
91.             {  
92.                 intArrayArray[i - 1] = new int[i];  
93.   
94.                 for (int j = 1; j <= i; j++)  
95.                 {  
96.                     intArrayArray[i - 1][j - 1] = i * j;  
97.                 }  
98.             }  
99.   
100.             ConsoleToClientArrayArrayInt(intArrayArray);  
101.               
102.             //二维数组   
103.             int[,] intArray2D = new int[9, 9];  
104.   
105.             Console.WriteLine(string.Format("二维数组 长度：{0},维数：{1}*{2}", intArray2D.Length,   
106.   
107. intArray2D.GetLength(0), intArray2D.GetLength(1)));  
108.   
109.             for (int i = 1; i < 10; i++)  
110.             {  
111.                 for (int j = 1; j <= i; j++)  
112.                 {  
113.                     intArray2D[i - 1, j - 1] = i * j;  
114.                 }  
115.             }  
116.   
117.             int count = 0;  
118.   
119.             foreach (int item in intArray2D)  
120.             {  
121.                 if (item > 0)  
122.                 {  
123.                     Console.Write("{0,2}", item);  
124.                 }  
125.   
126.                 if (++count >= 9)  
127.                 {  
128.                     Console.WriteLine();  
129.   
130.                     count = 0;  
131.                 }  
132.             }  
133.         }  
134.   
135.         static void ConsoleToClientArrayArrayInt(int[][] intArrayArray)  
136.         {  
137.             foreach (int[] item1 in intArrayArray)  
138.             {  
139.                 foreach (int item2 in item1)  
140.                 {  
141.                     Console.Write("{0,2}", item2);  
142.                 }  
143.   
144.                 Console.WriteLine();  
145.             }  
146.   
147.             Console.WriteLine();  
148.         }  
149.   
150.         static void ConsoleToClientString(string[] sArray)  
151.         {  
152.             foreach (string item in sArray)  
153.             {  
154.                 Console.Write(item + @",");  
155.             }  
156.   
157.             Console.WriteLine();  
158.         }  
159.   ///
160. ///注：@：用在字符串引号前，（1）表示字符串中的/不进行转译 (2)可以使用多行字符串（不建议使用） 不能在字符串中包含引号。
161. ////
162.         static void ConsoleToClientInt(int[] intArray)  
163.         {  
164.             foreach (int item in intArray)  
165.             {  
166.                 Console.Write(item + @",");  
167.             }  
168.   
169.             Console.WriteLine();  
170.         }  
171.   
172.         static void ConsoleToClientObject(object[] objArray)  
173.         {  
174.             foreach (object item in objArray)  
175.             {  
176.                 Console.Write(item.ToString() + @",");  
177.             }  
178.   
179.             Console.WriteLine();  
180.         }  
181.   
182.     }  

public class MyArray
    {
        /// <summary>
        /// 定义数组测试
        /// </summary>
        public void TestInt()
        {
            int[] intArry1 = null;

            intArry1 = new int[6];

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

            int[][] intArry3 = new int[9][];
        }
        
        /// <summary>
        /// 值类型数组转引用类型数组测试
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static object[] Int32ToArrayOfObject(int[] array)
        {
            object[] objArray = new object[array.Length];

            for (int i = 0; i < array.Length; i++)
            {
                objArray[i] = array[i];
            }

            return objArray;
        }
        /// <summary>
        /// 数组的主要特性测试
        /// </summary>
        public static void MainTest()
        {
            //声明一个包含是个元素的字符串型数组
            string[] sArray = new string[10];
            //访问数组
            //赋值
            for (int i = 0; i < sArray.Length; i++)
            {
                sArray[i] = @"string" + i;
            }

            ConsoleToClientString(sArray);

            //另一种方式声明数组，所谓的枚举法
            sArray = new string[] { "TestString0", "TestString1", "TestString2" };

            ConsoleToClientString(sArray);

            //数组复制
            string[] newSArray = sArray.Clone() as string[];

            ConsoleToClientString(newSArray);

            //使用Array的CreateInstance方法声明10元素的整形数组
            int[] intArray = Array.CreateInstance(typeof(int), 10) as int[];

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

            ConsoleToClientInt(intArray);

            //数组之间的复制，指定位置，指定长度
            int[] newIntArray = new int[20];

            Array.Copy(intArray, 3, newIntArray, 4, intArray.Length - 3);

            ConsoleToClientInt(newIntArray);

            object[] objArray = sArray;

            ConsoleToClientObject(objArray);

            objArray = Int32ToArrayOfObject(intArray);

            ConsoleToClientObject(objArray);

            //数组的数组
            int[][] intArrayArray = new int[9][];

            Console.WriteLine("数组长度：" + intArrayArray.Length);

            //赋值
            for (int i = 1; i < 10; i++)
            {
                intArrayArray[i - 1] = new int[i];

                for (int j = 1; j <= i; j++)
                {
                    intArrayArray[i - 1][j - 1] = i * j;
                }
            }

            ConsoleToClientArrayArrayInt(intArrayArray);
            
            //二维数组
            int[,] intArray2D = new int[9, 9];

            Console.WriteLine(string.Format("二维数组 长度：{0},维数：{1}*{2}", intArray2D.Length, 

intArray2D.GetLength(0), intArray2D.GetLength(1)));

            for (int i = 1; i < 10; i++)
            {
                for (int j = 1; j <= i; j++)
                {
                    intArray2D[i - 1, j - 1] = i * j;
                }
            }

            int count = 0;

            foreach (int item in intArray2D)
            {
                if (item > 0)
                {
                    Console.Write("{0,2}", item);
                }

                if (++count >= 9)
                {
                    Console.WriteLine();

                    count = 0;
                }
            }
        }

        static void ConsoleToClientArrayArrayInt(int[][] intArrayArray)
        {
            foreach (int[] item1 in intArrayArray)
            {
                foreach (int item2 in item1)
                {
                    Console.Write("{0,2}", item2);
                }

                Console.WriteLine();
            }

            Console.WriteLine();
        }

        static void ConsoleToClientString(string[] sArray)
        {
            foreach (string item in sArray)
            {
                Console.Write(item + @",");
            }

            Console.WriteLine();
        }

        static void ConsoleToClientInt(int[] intArray)
        {
            foreach (int item in intArray)
            {
                Console.Write(item + @",");
            }

            Console.WriteLine();
        }

        static void ConsoleToClientObject(object[] objArray)
        {
            foreach (object item in objArray)
            {
                Console.Write(item.ToString() + @",");
            }

            Console.WriteLine();
        }

    }

调用

[csharp] view plain copy print ?

1. class Program  
2. {  
3.     static void Main(string[] args)  
4.     {  
5.         MyArray.MainTest();  
6.   
7.         Console.ReadLine();  
8.     }  
9. }  

    class Program
    {
        static void Main(string[] args)
        {
            MyArray.MainTest();

            Console.ReadLine();
        }
    }

结果

由上可以知道：
数组有引用类型数组和值类型数组，对于引用类型数组，元素用于保存对象的引用，初始化值为null；对于值类型数组，元素保存

对象的值，对于数字类型初始化值为0。
数组有维度，但是多维数组和数组的数组是不同的概念，intArrayArray和intArray2D是不同的。数组的数组表示一个m*n的行列式

，多维数组则是每个元素都是一个数组对象的数组。
数组和其他集合类一样都是是实现了ICollection接口，都具有枚举和迭代功能。

代码下载：http://download.youkuaiyun.com/detail/yysyangyangyangshan/4640445