（九）CSharp-数组

一、矩形数组

1、访问数组元素

  class Program
    {
        static void Main(string[] args)
        {
            int[] intArr1 = new int[15];
            intArr1[2] = 10;
            int var1 = intArr1[2];

            int[,] intArr2 = new int[5, 10];
            intArr2[2, 3] = 7;
            int var2 = intArr2[2, 3];

            int[] myIntArray = new int[4];

            for (int i = 0; i < 4; i++)
                myIntArray[i] = i * 10;

            for (int i = 0; i < 4; i++)
                Console.WriteLine($"Value of element{ i } = { myIntArray[i] }");

            Console.ReadKey();
        }
    }

2、初始化

1）显式初始化一维数组

int[] intArr = new int[]{ 10,20,30,40 };

2）显式初始化矩形数组

int[,] intArray2 = new int[,]{ { 10,1},{ 2,10 },{ 11,9 } };

3）初始化矩形数组的语法点

int[,,] intArray = new int[4,3,2]{
{ { 8,6 },{ 8,6 },{ 8,6 } },
{ { 8,6 },{ 8,6 },{ 8,6 } },
{ { 8,6 },{ 8,6 },{ 8,6 } },
{ { 8,6 },{ 8,6 },{ 8,6 } },
};

4）快捷语法

//arr1 和 arr2 等价
int[] arr1 = new int[3]{ 10,20,30 };
int[] arr2 = { 10,20,30 };

//arr3 和 arr4 等价
int[,] arr3 = new int[2,3]{ { 0,1,2 }, { 0,1,2 } };
int[,] arr4 = { { 0,1,2 }, { 0,1,2 } };

3、隐式类型数组

int[] intArr1 = new int[] { 10,20,30,40 };int[]：显式
var intArr2 = new [] { 10,20,30,40 };//隐式定义

int[,] intArr3 = new int[,] { { 10,1 },{ 10,1 },{ 10,1 } } ;
var intArr2 = new    [,] { { 10,1 },{ 10,1 },{ 10,1 } } ;

atring[] sArr1 = new string[] { "life", "liberty","pureuit of happiness" };
var      sArr2 = new       [] { "life","liberty" ,"pureuit of happiness"}
//

二、交错数组

交错数组是数组的数组。交错数组的子数组的元素个数可以不同。

int[][] jagArr = new int[3][];

//比如：
//jagArr[0][x]：子数组有x个元素
//agArr[1][y]：子数组有y个元素
//agArr[2][x]：子数组有z个元素

1、声明交错数组

int [][] SomeArr;//秩等于3
int [][][] OtherArr; //秩等于3

2、快捷实例化

声明：

int[][] jagArr = new int[3][];

不能在声明语句中初始化顶层数组之外的数组。

int[][] jagArr = new int[3][4];//编译错误

//声明初始化时，如果把[3][]设置为[3][4]，则设置子数组为4是不被允许的。

3、实例化交错数组

class Program
    {
        static void Main(string[] args)
        {
            int[][,] Arr;
            Arr = new int[3][,];

            Arr[0] = new int[,] {   { 1, 2 }, { 10, 20 }   };

            Arr[1] = new int[,] {   { 1, 2 ,3}, { 10, 20,30 }   };

            Arr[2] = new int[,] {   { 1, 2,3,4 }, { 10, 20,30,40 }, { 100, 200, 300, 400 }   };

            //Arr.GetLength(0):获取 Arr 维度0的长度（维度是数组的层级）
            //Arr.GetLength(0) 是 int[3][x,y] 中的 3
            for (int i = 0; i < Arr.GetLength(0); i++)
            {
                //Arr[i].GetLength(0):获取 Arr[i] 维度0的长度
                //Arr[i].GetLength(0) 是 int[3][x,y] 中的 x
                for (int j = 0; j < Arr[i].GetLength(0); j++)
                {
                    //Arr[i].GetLength(1):获取 Arr[i] 维度1的长度
                    //Arr[i].GetLength(1) 是 int[3][x,y] 中的 y
                    for (int k = 0; k < Arr[i].GetLength(1); k++)
                    {
                        Console.WriteLine($"[{i}][{j},{k}] = { Arr[i][j,k] }");
                    }
                    Console.WriteLine("");

                }
                Console.WriteLine("");

            }

            Console.ReadKey();
        }
    }

输出结果：

[0][0,0] = 1
[0][0,1] = 2

[0][1,0] = 10
[0][1,1] = 20


[1][0,0] = 1
[1][0,1] = 2
[1][0,2] = 3

[1][1,0] = 10
[1][1,1] = 20
[1][1,2] = 30


[2][0,0] = 1
[2][0,1] = 2
[2][0,2] = 3
[2][0,3] = 4

[2][1,0] = 10
[2][1,1] = 20
[2][1,2] = 30
[2][1,3] = 40

[2][2,0] = 100
[2][2,1] = 200
[2][2,2] = 300
[2][2,3] = 400

4、比较矩形数组和交错数组

在 CIL中（中间语言），存在对一维数组进行性能优化的指令，而矩形数组没有这些指令。

四、foreach

1、迭代变量

由于迭代变量的值是只读的，所以它不能改变。

foreach(int item in arr1)
//item 是迭代变量

对值类型数组：

int arr1 = { 10,11,12,13 };

foreach(int item in arr1)
{
item++;//编译错误，不能改变 item 值
}

对引用类型数组：

MyClass[] mcArray = new MyClass[4];

foreach(int item in arr1)
{
item.MyField;//可以改变引用类型对象里的成员
item = null;//编译错误,不能改变 item 值。
}

2、foreach 语句和多维数组

示例

   class Program
    {
        static void Main(string[] args)
        {
            //矩形数组的示例
            int[,] arr1 = { { 10, 11 }, { 12, 13 } };

            foreach (var element in arr1)
            {
                //....
            }

            //交错数组的示例
            int[][] arr2 = new int[2][];
            arr2[0] = new int[] { 10, 11 };
            arr2[1] = new int[] { 12, 13, 14 };

            foreach (int[] array in arr2)
            {
                foreach (int item in array)
                {
                    //....
                }

            }
            Console.ReadKey();
        }
    }

五、数组协变

在某些情况下，即使某个对象不是数组的基类型，也可以把它赋值给数组元素。这种属性叫作数组协变。

可进行数组协变的条件：

• 数组是引用类型数组。
• 在赋值的对象类型和数组基类型之间有隐式转换或显式转换。

class A { }
    class B : A { }

    class Program
    {
        static void Main(string[] args)
        {
            A[] AArray1 = new A[3];
            A[] AArray2 = new A[3];

            AArray2[0] = new B();//产生协变
            AArray2[1] = new B();//产生协变
            AArray2[2] = new B();//产生协变
            Console.ReadKey();
        }
    }

六、数组继承的有用成员

1、数组基类继承的属性和方法

C# 数组派生自 System.Array 类。它们可以从基类继承很多有用的属性和方法。

表-数组继承的一些有用成员

成员	类 型	生存期	意义
Rank	属性	实例	获取数组的维度数
Length	属性	实例	获取数组中所有维度的元素总数目
Getlength	方法	实例	返回数组的指定维度的长度
Clear	方法	静态	将某一范围内的元素设置为 0 或null
Sort	方法	静态	在一维数组中对元素进行排序
BinarySearch	方法	静态	使用二进制搜索，搜索一维数组中的值
Clone	方法	实例	进行数组的浅复制——对于值类型数组和引用类型数组，都只复制元素
IndexOf	方法	静态	返回一维数组中遇到的第一个值
Reverse	方法	静态	反转一维数组中某一范围内的元素
GetUpperBound	方法	实例	获取指定维度的上限

使用其中一些属性和方法的例子：

   class Program
    {
        public static void PrintArray(int[] a)
        {
            foreach (var x in a)
                Console.Write($"{ x }  ");

            Console.WriteLine("");
        }

        static void Main(string[] args)
        {
            int[] arr = new int[] { 15, 20, 5, 25, 10 };
            PrintArray(arr);

            Array.Sort(arr);
            PrintArray(arr);

            Array.Reverse(arr);
            PrintArray(arr);

            Console.WriteLine();
            Console.WriteLine($"Rank = { arr.Rank },Length = { arr.Length }");
            Console.WriteLine($"GetLength()     = { arr.GetLength(0) }");
            Console.WriteLine($"GetType()       = { arr.GetType() }");

            Console.ReadKey();
        }
    }

输出结果：

15 20 5 25 10
5 10 15 20 25
25 20 15 10 5
.
Rank = 1,Length = 5
GetLength() = 5
GetType() = System.Int32[]

2、Clone() 方法

Clone 方法为数组进行浅复制，它只创建了数组本身的克隆。

• 克隆值类型数组会产生两个独立数组。
• 克隆引用类型数组会产生指向相同对象的两个数组。

int[] intArr1 = { 1,2,3 };
int[] intArr2 = (int[]) intArr1.Clone();
//int[]：数组类型
//Clone()：返回 object

3、比较数组类型

表总结了3种类型的数组的重要相似点和不同点——比较数组类型的总结。

数组类型	数组对象	语法	语法	形状
一维： ◾ 在CIL 中有优化指令	1	单组	🚫
矩形：◾ 多维度◾ 多维数组中的子数组必须长度相同	1	单组	✅
交错：◾ 多维度◾ 子数组的长度可以不同	多个	多组	🚫