C# 数组相关：不可变数组、多维数组、交错数组、隐式类型化数组、 数组协变、 Array类

数组

1. 数组是 引用类型；

2. int[ ] 中 int 也是类型，所以数组可以认为是复合类型

3. 数组名最好加 s

4. 数组是集合，集合不一定是数组

5. 数组的元素 的类型 既可以是引用类型也可以是值类型；分别称为：引用类型数组 和 值类型数组。

6. 创建数组实例后，其每个元素都有默认值，string 的为空字符串，int 的为 0 ，bool 的为 false，引用类型的为 null；

不可变数组

含义:

不可变数组是一个存储相同类型元素的固定大小的顺序集合

特点:

1. 数组属于引用类型
2. 数组只能包含类型相同的元素
3. 数组通过下标（索引值）标记元素 下标从0开始 依次加1

格式：

//声明数组：
int[ ] arrayName;
//•int 用于指定被存储在数组中的元素的类型。
//•指定数组的秩 [维度] 。秩指定数组的大小。
//•arrayName 指定数组的名称。

初始化元素的方法：

•数据类型[] 数组名 = {值 1, 值 2, …}
int[ ]  yk = {1,2,3}

•数据类型[] 数组名 = new 数据类型[长度]{值 1，值 2,…}
int[ ]  yk = new int [3]{1，2，3};
•数据类型[] 数组名 = new 数据类型[长度可忽略]{值 1，值 2,…}
int[ ]  yk = new int [ ]{1，2，3};
•数据类型[] 数组名 = new 数据类型[长度];
//如果不给元素赋值会给一个当前数据类型的默认值
int[ ]  yk = new int [5];
yk[0] = 10;
yk[2] = 20;

//空数组
int[ ]  yk = {   };

数组API 实例方法

1. 数组名.Length //数组的长度

   • GetLength //对于多维数组，获取指定维度的长度

     int[,] myArray = new int[3, 4];
     
     // 获取第一维（行）的长度
     int rows = myArray.GetLength(0);  
     
     // 获取第二维（列）的长度
     int cols = myArray.GetLength(1);  
     

2. 数组名.Sum() //数组的和

3. 数组名.Max //数组的最大值

4. 数组名.Min //数组的最小值

5. 数组名.Append //末尾追加

   • C# 中的数组本身是固定长度的，不支持直接使用 Append 方法

   • 数组名 = 数组名.Append(4).ToArray()  //使用ToArray，间接使用Append追加
     

6. 数组名.Where //筛选，返回可枚举对象

   • //筛选出符合item>100的元素，然后通过ToArray组合成新的数组
     var arr = 数组名.Where((item) => {
       return item>100
     }).ToArray();
     

7. 数组名.GetValue(2) //获取指定索引位置的<元素

   • 数组名.SetValue(2) //设置数组中指定索引位置的元素

     
     

8. 数组名.Contains //是否包含某个元素，返回bool

9. 数组名.Rank //获取数组的维数（佚）

   1. 数组名.CopyTo //复制

      参数1:把复制的内容放到哪个数组中
      参数2:从源字符串哪个索引位置开始复制
      str. CopyTo(chars,1);  //把数组str从索引1开始放到数组chars中
      

10. 数组名.Clone //克隆，有装箱，返回object类型,建议克隆后强转

11. 数组名.ElementAt //等于 数组名[ ]

    
    

12. 数组名.First //数组第一个元素

    • FirstOrDefault //返回数组中第一个元素值

13. 数组名.Last //数组最后一个元素

    • LastOrDefault //返回数组中最后一个元素值

​

14. 数组名.Distinct //去除重复元素

15. 数组名.GetType //获取对象的运行时类型

多维数组

含义：

多维数组，超过1维，判断是几维就看 [ ] 中有几个** ，**

二维位数组格式：

//[行，列]
int [, ] yk =new int [数组个数,数组元素个数]
  
//如2行2列：
int [, ] yk =new int [,]{1,2}，{3,4};
//                    {1，2}
//                    {3，4}

三维数组格式：

int [,,] strArray =new int[数组页数,数组个数,数组元素个数]
//如2页2行2列
int [,,] strArray =new int[2,2,2]{ {{1,2},{1,2}} , {{5,6},{5,6}} }
//                         {1,2}
//                         {1,2}
//                          
//                         {5,6}
//                         {5,6}

//三维数组访问元素：
int val = a[2,2,2];
//三维数组修改元素：
a[2,2,2]=10；

隐式类型化数组

int[] a = new int[]{1, 2};
// var的隐式推断，因为可以从 {1,2} 推断出数组时int类型
var a = new []{1, 2};  //int[] --> var

交错数组

含义

交错数组就是数组嵌套

交错数组格式：

int [][] scores = {new int [2] {1,2}, new int[3] {1,2,3}};
//选中第一个数组中的“2”：
int a = scores[0][1];

//第一个[]： 就是有几个嵌套数组
//第二个[]:  有几个元素
int [][] scores = new int[3][];
scores[0] = new int[]{1,2};
scores[1] = new int[]{1,2,3};
scores[2] = new int[]{1,2,3,4};

数组协变

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

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

如：声明了两个类，A和B，其中B类继承自A类。最后一行展示了把类型B的对象赋值给类型A的数组元素而产生的协变：

//1.声明一个父类A和子类B
//2.在主函数中定义一个数组A[]
class A {...}
class B: A {...}

A[] AArray1 = new A[3];
A[] AArray2 = new A[3];

// 普通：将A类型的对象赋值给A类型的数组
AArray1[0] = new A();
AArray1[1] = new A();
AArray[2] = new A();

// 协变：将B类型的对象赋值给A类型的数组
AArray2[0] = new B();
AArray2[1] = new B();
AArray2[2] = new B();

Array类

含义：

是一个抽象类

是 C# 中所有数组的基类，它是在 System 命名空间中定义 提供了各种用于数组功能的属性和方法。

创建一维数组：

//正常创建
int[] intArray = new int[3]; 
intArray[0] = 886; 

//用Array基类创建
Array intArray = Array .CreateInstance(typeof(int), 3); //基类
intArray.SetValue(886,0);    //把886赋给第一个数

创建二维数组：

int[,] intArray = new int[2,2];  //正常创建二维数组
intArray[0, 0] = 100;
intArray[0, 1] = 200;
Console.WriteLine(intArray[0,0]);

Array intArray= Array .CreateInstance(typeof(int), 2,2);  //用Array创基类创建
intArray.SetValue(100,0,0);
intArray.SetValue(200,0,1);

Array类API 静态方法

1. 字符串.ToCharArray(); //把字符串分割为一个字符数组

2. .ToArray(); //将一些可枚举的对象转换为数组

3. .Reverse(); //反转数组

   • Array.Reverse() //反转数组本身，没有返回值
   • 数组名.Reverse() //返回可枚举对象

4. Indexof //查找是否存在于数组中，如果存在，返回元素索引，如果不存在返回false

   • Array .Indexof(intArray,886);         //元素1：数组名    元素2：要查询的元素
     

5. FindAll //从给定的数组中查找并返回所有满足特定条件的元素，然后将这些元素组成一个新的数组返回。

   • Find //查找一个匹配的元素

   • FindLast //查找最后一个匹配的元素

   • FindIndex //查找一个匹配的元素的索引

   • FindLastIndex //查找最后一个匹配的元素的索引

     arr a = Array. Find (arr,(item) => {
       return item==200;
     }  //查找其中值==200的元素
     arr.Find(item => item == 200);  //简写
                          
     arr[] a = Array. Find (arr,(item) => {
       return item==200;
     }  //查找其中所有值==200的元素然后将这些元素组成一个新的数组
     
     arr.FindIndex(item => item == 200);  //FindIndex  简写
     

6. Count(); //数组元素数

7. Sort //从小到大排序 （改变自身）

8. Clear //将某个范围内的所有元素设为初始值

   • //参数1：数组名
     //参数2: 从索引几开始
     //参数3: 清空几个
     Array .Clear(数组名,0,2);       //将从索引“0”开始，长度为2的数重置为默认值
     

9. Copy //静态方法深复制数组内容到另一个数组

   //参数1：源数组
   //参数2: 目标数组
   //参数3: 从索引几开始复制
   Array.Copy(源数组,目标数组,0)
   

   • 数组名.CopyTo //实例方法

10. ForEach //循环

    • //Action arr = () => {} 拉姆达表达式（回调函数）
      Action 是一种委托类型，用于表示没有返回值的方法
      
        //参数1.数组
        //参数2.拉姆达表达式（回调函数）
        Array.ForEach (arr,(item) => { 
      
        });  //为数组 arr 中的每一个元素 item 执行 {} 中的函数
      

11. Exists //包含，返回bool

    Array.Exists (arr,(item) => { 
      if (item>10){
        return true;
      }else{
        return false;
      }
    });  
    

12. Array.ConvertAll //数组类型转换,不会修改自身

    //参数1. 数组名
    //参数2. 使用的转换方法
    Array.ConvertAll(strings, int.Parse);
    

13. Concat //拼接数组，返回 接口IEnumberator 类型

14. Insert //插入