C#数组和集合

一维数组

　　概述：数组是通过指定数组的元素类型、数组的（秩）维数及数组每个维度上的上限和下限来定义的，及一个数组的定义需要包含以下几个要素。

　　类型   数组的维数   每个维的上限下限

　　声明：数据类型  标识符  【正整数常量】;

　　数组类型是从抽象基类型Array派生的引用类型，通过new运算符创建数组并将数组元素初始化为它们的默认值。

一维数组的声明和使用：

　　静态一维数组：

　　　　它是指数组元素的个数是固定不变的，即它们占用的内存空间大小是不变的。

　　　　一维数组是具有相同数据类型的一维数据类型的集合。

　　声明如下：type[ ] arrayName;

　　初始化有很多方法：

           1.    int[ ] arr = new int[5];

           2.    int[ ] arr = new int[5]{1,2,3,4,5};

           3.    string[ ] arrstr;

　　　　　　arrstr = new striing[7]{“sun”,”Mon”,”Tue”,”Wed”,”Thu”,”Fir”,”Sat”};

　　动态一维数组

　　　　动态数组的声明实际上就是将数组的声明部分和初始化部分，分别写在不同的语句中，动态数组的初始化也需要使用new关键字为数组元素非配内存空间，为数组元素赋初值。

　　动态一维数组元素的声明如下：

　　　　type [ ] arrayName;

　　　　arrayName = new type[n];

　　　　或

　　　　type[ ] arrayname = new type[ ];

　　对动态一维数组声明完以后，可以利用Length属性获取数组中元素的总数，并用for语句或foreach语句对数组进行动态赋值。

二维数组：

　　静态二维数组：

　　声明语法如下：

　　　　type[,] arrayName;

　　注：定义值类型的数组时，其默认值为0（包括整形，单精度，双精度），布尔类型默认值为false，字符数组默认值为’\0’，字符串默认值为null。

　　在声明二维数组的同时直接进行初始化，可以省略new关键字，编译器将根据初始值的数量计算数组长度，并创建二维数组。

　　动态二维数组：

　　声明语法如下：

　　　　Type[ , ] arrayName;

　　　　arrayName = new type[n1,n2];

　　　　或：

　　　　Type[ , ] arrayName = new type[n1,n2];

　　对动态二维数组声明完以后，可以通过给Array类对象的GetLength方法传递不同的参数，来获取二维数组的行数和列数，从而获取到二维数组中的每个元素。

static void Main(string[] args)
        {
            /*
             int[] arr = new int[6];
            Console.WriteLine("请输入一维数组：");
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = Convert.ToInt32(Console.ReadLine());
            }
            Console.WriteLine("显示输入的数组：");
            foreach (int item in arr)
            {
                Console.Write("{0}",item+",");
            }
            Console.WriteLine();
             */

            /*
             int[,] arr = new int[3, 2] {{1,1},{2,2},{3,3} };
            Console.Write("数组的行数为：");
            Console.WriteLine(arr.GetLength(0));
            Console.Write("数组的列数为：");
            Console.WriteLine(arr.GetLength(1));
            Console.Write("\n");
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                string str = "";
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    str = str + Convert.ToString(arr[i, j]) + " ";
                }
                Console.Write(str);
                Console.Write("\n");
            }
             */
            /*
             int row = 0, col = 0;
            Console.Write("请输入二维数组的行数：");
            row = Convert.ToInt32((Console.ReadLine()));
            Console.Write("请输入二维数组的列数：");
            col = Convert.ToInt32((Console.ReadLine()));

            Console.WriteLine("请输入二维数组的值：");
            int[,] arr1 = new int[row, col];
            for (int i = 0; i < arr1.GetLength(0); i++)
            {
                for (int j = 0; j <arr1.GetLength(1); j++)
                {
                    arr1[i, j] = Convert.ToInt32((Console.ReadLine()));
                }
            }

            //显示
            Console.WriteLine("显示输入的二维数组：");
            for (int i = 0; i < arr1.GetLength(0); i++)
            {
                for (int j = 0; j < arr1.GetLength(1); j++)
                {
                    Console.Write(arr1[i,j]+" ");
                }
                Console.WriteLine();
            }
             */
            
            /*
             // 冒泡排序
            int[] arr = new int[]{1,4,3,5,7,2,6,10,9,8};
            int temp;
            Console.Write("排序前：");
            foreach (int item in arr)
            {
                Console.Write(item+" ");
            }
            Console.WriteLine();
            Console.Write("排序后：");
            for (int i = 0; i < arr.Length-1; i++)
            {
                for (int j = i+1; j < arr.Length; j++)
                {
                    if (arr[i] > arr[j])
                    { 
                        temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
            }
            foreach (int item in arr)
            {
                Console.Write(item+" ");
            }
             */
            
            /*
             // 选择排序
            int[] arr = new int[] { 10,2,3,6,4,9,8,1,5,7};
            Console.Write("排序前：");
            foreach (int item in arr)
            {
                Console.Write(item+" ");
            }
            Console.WriteLine();
            Console.Write("排序后：");
            int min;
            for (int i = 0; i < arr.Length-1; i++)
            {
                min = i;
                for (int j = i+1; j < arr.Length; j++)
                {
                    if (arr[min] > arr[j])
                        min = j;
                }
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
            foreach (int item in arr)
            {
                Console.Write(item+" ");
            }
             */
            
            Console.WriteLine();
            Console.ReadLine();
        }

 

ArrayList集合类：

　　ArrayList集合位于System.Collections命名空间下，它可以动态的添加和删除元素，是一种非泛型集合类。ArrayList相当于一种高级的动态数组，它是Array类的升级版本，但它并不等同于数组。

ArrayList类概述：

   1、数组的容量是固定的，而ArrayList的容量可以根据需要自动扩充

   2、ArrayList提供添加、删除和插入某一范围元素的方法，但在数组中自能一次获取或设置一个元素的值。

   3、ArrayList将提供只读和固定大小包装返回到集合的方法，而数组不提供。

   4、ArrayList只是一维形式，而数组可以是多维的。

其属性如下：

Capacity	获取或设置 ArrayList 可包含的元素数。
Count	获取 ArrayList 中实际包含的元素数。
IsFixedSize	获取一个值，该值指示 ArrayList 是否具有固定大小。
IsReadOnly	获取一个值，该值指示 ArrayList 是否为只读。
IsSynchronized	获取一个值，该值指示是否同步对 ArrayList 的访问（线程安全）。
Item	获取或设置指定索引处的元素。
SyncRoot	获取可用于同步 ArrayList 访问的对象。

方法：

添加：

　　public virtual int Add (object value);

　　public virtual void Insert(int index,object value);

删除：

　　public virtual void Clear();        //清除所有元素

　　public virtual void Remove();   //移除特定对象的第一个匹配项

　　public virtual void RemoveAt(int index);//移除指定索引处的元素

　　public virtual void RemoveRange(int index,int count);//移除指定索引处的元素

　　index：起始索引

　　count：要移除的元素数