C(sharp)数组与集合

4.1一维数组

4.2二维数组

4.3Array类

4.4ArrayList类

4.5List<T>类

4.1.1一维数组的定义

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

//语法格式如下
//数组类型[] 数组名;
//例如
    int[] a1,a2;
    double[] b1,b2;
    string[] c1,c2;
//在定义数组后，必须对其进行“初始化”才能使用
//初始化分为：动态初始化，静态初始化

4.1.2一维数组的初始化

1、一维数组的动态初始化

（1）动态初始化需要借助new运算符，为数组元素分配内存空间，并为数组元素赋初值。

动态初始化数组的格式：

        数组类型[] 数组名 = new 数据类型[n] {元素0，元素1，元素2·······，元素n}

        其中n是数组长度，可以是整形常量或变量，后面一层大括号里为初始值部分。

        //如果给出n的值，则初值元素个数应该与数组长度n相同

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

或者

        //数组长度n省略不写，因为后面的花括号中已经列出了数组中的全部元素

        int[] b1=new int[] {1,2,3,4,5,6,7,8,9,10};//此时的元素个数为10个=>n等于10

（2）数组若不指定初始值部分则各元素取默认值

*1数值类型初始化为0

*2布尔类型初始化为false

*3字符串类型初始化为null

//例如
    int[] mayyr = new int[5];
    foreach(int i in mayyr)
    {
        Console.WriteLine(i);
    }
/*输出为
0
0
0
0
0
*/

       注意

        ****如果数组给定初始值，不允许数组长度是变量，即使是变量先赋值也不可以

//不符合上面*后的规定所以错误
int n = 5;
int[] myarr = new int[n] { 1, 2, 3, 4, 5 }; //错误

        ****数组如果没有给定初始值，数组长度是可以是已经初始化的变量

//符合上*的条件，所以正确
int n = 5;
int[] myarr = new int[n];    //正确，指定数组长度为n

        ****如果给出数组长度，则初始值元素个数应与数组长度相同，否则出错

int[] mya = new int[2] {1,2};　  //正确
int[] mya = new int[2] {1,2,3};	  //错误
int[] mya = new int[2] {1};　　  //错误

2、一维数组的静态初始化

        静态初始化数组时，必须与数组定义结合在一起，否则会出错。

        静态初始化数组的格式如下：

        数组类型[] 数组名 = {元素0，元素1，元素2，元素3，元素n，元素n-1}；

        用这种该方法对数组进行初始化时，无需说明数组元素的个数，只需要按照顺序列出数组中的全部元素即可，系统会自动计算平分配数组所需的内存空间。

        例如，以下是对整型数组myaar的静态初始化如下：

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

        在这种情况下，不能将数组定义和静态初始化分开。

int[] myarr;
myarr={1,2,3,4,5};　		//错误的数组的静态初始化

4.1.3一维数组元素访问

        访问一维数组中的某个元素:

                名称[下标或索引]

例如：

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

for (int i = 0; i < 6; i++)
{
    Console.Write(myIntArray[i]);
}

// myIntArray.Length:数组所有维数中元素的总数
for (int i = 0; i < myIntArray.Length; i++)
{
    Console.Write(myIntArray[i]);
}

例如：
     int[] myIntArray = new int[6] { 1, 2, 3, 4, 5, 6 };
     foreach (int item in myIntArray)
     {
          Console.Write(item);
     }

注：下标越界时C#系统会提示以下出错信息：     未处理的异常: System.IndexOutOfRangeException:索引超出了数组界限。

4.2.1二维数组的定义

        二维数组可以看成是数组的数组，他们的每一个元素又是一个一维数组，因此需要两个下标才能标识某个元素的位置，二维数组经常用来按行和按列存放信息。

        语法格式如下：

        数组类型[,] 数组名；

例如：
    int[,] a1,a2;     //定义整型二维数组a1、a2
    double[,] b;      //定义双精度二维数组b
    string[,] c;      //定义字符串二维数组c
扩展:      
    int[,,] p;        //定义了一个三维数组p

4.2.2二维数组额初始话

        1、二维数组的动态初始化

        动态初始化需要借助new运算符，为数组元素分配内存空间，并为数组元素赋初值，若不指定初始值，部分则各元素取默认值；

数据类型[,] 数组名=new 数据类型[m,n]

数据类型[,] 数组名=new 数据类型[m,n] { 
              	 {元素值0,0,元素值0,1,,元素值0,n-1},
              	 {元素值1,0,元素值1,1,,元素值1,n-1},
              	      
              	 {元素值m-1,0,元素值m-1,1,,元素值m-1,n-1}  };
其中，m、n分别为行数和列数，即各维的长度，可是整型常量或变量

        2、二维数组的静态初始化

        静态初始化数组时，必须与数组定义结合在一起，否则会出错。

        

静态初始化数组的格式如下：
    数据类型[,] 数组名={ {元素值0,0,元素值0,1,,元素值0,n-1},
    {    元素值1,0,元素值1,1,,元素值1,n-1},
        
    {    元素值m-1,0,元素值m-1,1,,元素值m-1,n-1}  };
例如，以下语句是对整型数组myarr的静态初始化：
    int[,] myarr={{1,2,3},{4,5,6}};

4.2.3二维数组元素访问

        访问二维数组元素需指定数组名称和数组中该元素的行下表和列下标。

static void Main(string[] args)
{
     int[,] a = new int[2, 3] { { 1,2,3}, { 4,5,6} };
     int i, j;
     for (i = 0; i < 2; i++)
     {
          for (j = 0; j < 3; j++)
          {
               Console.Write("{0} ",a[i,j]);
          }
          Console.WriteLine();
     }
     Console.ReadLine();           
}

//输出结果如下
1 2 3
4 5 6

4.3Array类

        System.Array类型是所有数组类型的抽象基本类型，所有的数组类型均由它派生，任何数组都可以使用System.Array具有的属性及其方法。

注意：由于Array类是抽象类，不能创建它的对象，例如“Array arr=new Array();”语句是错误的，但它提供了一些静态方法，通过类名来调用这些静态方法，例如，Array.sort(a)是对数组a进行排序。

属性	说明
Length	数组的长度（32位整数），该整数表示Array的所有维数中元素的总数。
LongLength	数组的长度（64位整数），该整数表示Array的所有维数中元素的总数。
Rank	获取Array的秩（维数）。

例如：int[,] a = new int[2, 3] { { 1,2,3}, { 4,5,6} };          
      Console.WriteLine(a.Length); //输出结果为6

System.Array类常用的方法使用格式

        1、Array.BinarySearch(Array,item):在整个一维排序数组Array中搜索特定元素item

int[] a = new int[] { 1, 2, 3, 4, 5 ,6};
   int i = Array.BinarySearch(a,3);
   Console.WriteLine(i); //运行结果为  2

        2、Array．Copy（Array1，Array2，n）：从第一个元素开始复制Array1中的一系列元素，将它们粘贴到Array2中（从第一个元素开始），共复制n个元素。

  int[] a1 = new int[] { 1, 2, 3, 4, 5 ,6};
   int[] a2 = new int[] { 7, 8, 9, 10, 11, 12 };
   Array.Copy(a1,a2,4);
   foreach (int i in a2)
   {
        Console.WriteLine(i);
   }

//输出为
1
2
3
4
11
12

        3、Array.sort(Array):对整个一维Array中的元素进行排序

   int[] a = new int[] { 1,2,7,4,3 };
   Array.Sort(a);
   foreach (int i in a)
   {
       Console.WriteLine(i);
   }
/*
1
2
3
4
7
*/

 4、Array. Reverse（Array）：反转整个一维Array中元素的顺序。

   int[] a = new int[] { 1,2,7,4,3 };
   Array.Reverse(a);
   foreach (int i in a)
   {
       Console.WriteLine(i);
   }
/*
3
4
7
2
1
*/

例题

static void Main(string[] args)
{
     int i;
     int[] myarr = new int[10];         //定义一个一维数组
     Random randobj = new Random();     //定义一个随机对象
     for (i = 0; i < myarr.Length; i++)
     {
        myarr[i] = randobj.Next() % 20; //返回一个0~19的正整数        
     }
     Console.Write("随机数组：");          
     foreach (int num in myarr)
     {
        Console.Write(num+" ");
     }
     Console.WriteLine();
     Array.Sort(myarr);                //数组的排序
     Console.Write("排序数组：");
     foreach (int num in myarr)
     {
        Console.Write(num+" ");
     }       
     Console.ReadLine();
}

输出为随机数组：4 5 1 5 7 12 12 6 13 17

           排序数组：1 4 5 5 6 7 12 12 13 17

4.4 ArrayList类

ArrayList类（在命名空间System.Collections中），用于建立不定长度的数组，由于该类数组的数据类型为Object，其长度不固定，可以将其对象看成是一个集合。

定义ArrayList类的对象的语法格式如下：     ArrayList 数组名 = new ArrayList( );

例如，以下语句定义一个ArrayList类的对象myarr

可以将它作为一个数组使用：     ArrayList myarr = new ArrayList( );

1、Array的容量或元素个数是固定的，而ArrayList的容量可以根据需要动态扩展，通过设置ArrayList．Capacity的属性值可以执行重新分配内存和复制元素等操作。

2、可以通过ArrayList提供的方法在集合中追加、插入或移除一组元素，而在Array中一次只能对一个元素进行操作。

3、在ArrayList中可以存放多种数据类型，此时的取值操作要强制转换，即拆箱。

4、Array的起始下标是可以设置的，而ArrayList的起始下标始终是0。

5、Array可以是多维的，而ArrayList始终是一维的。

属性	说明
Capacity	获取或设置ArrayList可包含的元素数。
Count	获取ArrayList中实际包含的元素数。
Item	获取或设置指定索引处的元素。

using System.Collections;
……
static void Main(string[] args)
{
      ArrayList a1 = new ArrayList() { 1,2,3,"abc",'d’};
      //Capacity默认为4，如果add元素超过4那么Capacity*2，以此类推
      int capacity = a1.Capacity;
      int count = a1.Count;
      Console.WriteLine(a1[3]);
      Console.WriteLine("{0}",capacity);
      Console.WriteLine("{0}",count);       
      Console.ReadLine();
}

输出
abc
8
5

方  法	说  明
Add	将对象添加到ArrayList的结尾处。
Insert	将元素插入ArrayList的指定索引处。
Clear	从ArrayList中移除所有元素。
Remove	从ArrayList中移除特定对象的第一个匹配项。
RemoveAt	移除ArrayList的指定索引处的元素。
Contains	确定某元素是否在ArrayList中。
CopyTo	将ArrayList或它的一部分复制到一维数组中。
Reverse	将ArrayList或它的一部分中元素的顺序反转。
Sort	对ArrayList或它的一部分中的元素进行排序。
ToArray	将ArrayList的元素复制到新数组中。
ToString	返回表示当前Object的String。
TrimToSize	将容量设置为ArrayList中元素的实际数目。

//ArrayList常用方法使用举例。
using System.Collections;
…………

public static void showArrayList(ArrayList arrayList,string title)
{
      Console.WriteLine("========={0}=========",title);
      foreach (object item in arrayList)
      {   Console.Write(item);      }
      Console.WriteLine();
      Console.WriteLine();
}
static void Main(string[] args)
{
      //创建ArrayList对象
      ArrayList arrayList = new ArrayList();
      //添加
      arrayList.Add("d");
      arrayList.Add("c");
      arrayList.Add("b");
      arrayList.Add("a");
      showArrayList(arrayList, "Add");

      rrayList.Insert(2,"H"); //index,value
      showArrayList(arrayList,"Insert");

      arrayList.Remove("H"); //obj
      showArrayList(arrayList,"Remove");

      arrayList.RemoveAt(0); //index
      showArrayList(arrayList,"RemoveAt");
      //排序
      arrayList.Sort();
      showArrayList(arrayList, "Sort");
      //反转
      arrayList.Reverse();
      showArrayList(arrayList, "Reverse");
      //查找
      int s = arrayList.IndexOf("b"); //查找指定内容的索引
      Console.WriteLine("========={0}=========","IndexOf");
      Console.WriteLine(s);
      //清空
      arrayList.Clear();
      showArrayList(arrayList, "Clear");
      Console.ReadLine();
}