C# 数组

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

数组是使用类型声明的：

type[] arrayName;

数组概述

数组具有以下属性：

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

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

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

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

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

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

 //数组可以是任何C#类型（下面以int类型的数组为例）
            //一维数组，实例化(四种方式)
            //(1)
            int[] a = new int[3];
            a[0] = 1;
            a[1] = 2;
            a[2] = 3;
            //(2)
            int[] b = new int[3] { 1, 2, 3 };
            //(3)
            int[] c = new int[] { 1, 2, 3 };
            //(4)
            int[] d = { 1, 2, 3 };
            //注意：使用第四种方式时，一定要一步完成。意思是：声明和复制要在一句代码里，如果先申明，再以赋值则编译不通过，如下：
            int[] f;
            //f={1,2,3}; //Error
            f = new int[] { 1, 2, 3 }; //OK

            //二维或多维数组
            int[,] g = new int[2, 3];
            g[0, 0] = 11;
            g[0, 1] = 12;
            g[0, 2] = 13;

            g[1, 1] = 21;
            g[1, 2] = 22;
            g[1, 3] = 23;
            //多维
            int[, ,] h = new int[2, 3, 4];
            h[0, 0, 0] = 101;
            h[0, 0, 1] = 102;
            h[0, 0, 2] = 103;
            h[0, 0, 3] = 104; //4个（一组4个）

            h[0, 1, 0] = 111;
            h[0, 1, 1] = 112;
            h[0, 1, 2] = 113;
            h[0, 1, 3] = 114;

            h[0, 2, 0] = 121;
            h[0, 2, 1] = 122;
            h[0, 2, 2] = 123;
            h[0, 2, 3] = 124;//3小组（一组四个)

            h[1, 0, 0] = 201;
            h[1, 0, 1] = 202;
            h[1, 0, 2] = 203;
            h[1, 0, 3] = 204;

            h[1, 1, 0] = 211;
            h[1, 1, 1] = 212;
            h[1, 1, 2] = 213;
            h[1, 1, 3] = 214;

            h[1, 2, 0] = 221;
            h[1, 2, 1] = 222;
            h[1, 2, 2] = 223;
            h[1, 2, 3] = 224;//2大组(一组三小组）

            //当然它也可以这样声明
            int[,] i = new int[2, 3] { { 1, 2, 3 }, { 4, 5, 6 } };
            int[,] j = new int[,] { { 1, 2 }, { 3, 4 } };
            int[, ,] k = new int[2, 3, 4] {
                {
                    {1,2,3,4},
                    {1,2,3,4},
                    {1,2,3,4}
                },
                {
                    {1,2,3,4},
                    {1,2,3,4},
                    {1,2,3,4}
                }
            };
            int[, ,] l = new int[,,] { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };

            //交错数组 (数据元素还是数组)
            int[][] m = new int[3][];
            m[0] = new int[2];
            m[1] = new int[3];
            m[2] = new int[2];

            m[0][0] = 1;
            m[0][1] = 2;

            m[1][0] = 1;
            m[1][1] = 2;
            m[1][2] = 3;

            m[2][0] = 1;
            m[2][1] = 2;

            //当然它也可以这样实例化
            int[][] o = new int[3][] { new int[2] { 1, 2 }, new int[3] { 1, 2, 3 }, new int[2] { 2, 3 } };
            //或
            int[][] p = new int[][] { new int[] { 1, 2, 3 }, new int[] { 2, 3 }, new int[] { 1, 2, 3, 4 } };
            //或
            int[][] q =
            {
                new int[] { 1, 2 },
                new int[] { 2, 3, 4 },
                new int[] { 2, 4, 5, 6 }
            };

            //交错多维混合数组
            //可以混合使用交错数组和多维数组。下面声明和初始化一个一维交错数组，该数组包含大小不同的二维数组元素：
            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} }
            };