集合
1、集合和数组一样都是存储类型相同的堆栈序列，其内部实际上是维护一个数组。但是数组是定长的，而集合是变长的，集合内部的数据的进出都是有一定顺序的。因为集合是引用类型的，所以实例化时采用new关键字，可以为集合赋一个初始容量，但实际上不建议这样做，集合的容量都是以4,8,16成倍增加的，其内维护的是一个数组，当元素个数超出了这个数组长度时系统就会重新为集合设置一个新的数组，容量在原来的基础上乘以2，例ArrayList al = new ArrayList();
   集合增加元素的方法用 al.Add(1);，获取元素类似数组的获取法，用下标实现，得到集合元素个数用 al.Count，得到集合容量用al.Capacity。
   移除集合元素有两种方法：1、al.Remove(1);//移除元素1，移的时候只匹配第一个找到的值 2、al.RemoveAt(2);//移除下标为2的元素
   清空集合元素的方法（只清空元素个数，容量不会改变）
        ArrayList al = new ArrayList();//集合是引用类型的，使用new实例化，如果给定一个参数时表示集合的容量
                                           //建议不要为集合初始化就为容量赋初始值
            al.Add(1);//此处发生装箱，因为Add方法只添加object类型的值，所以当赋值时先将数据类型做了一个转换，即将
                      //数值类型转换成引用类型
            al.Add(2);
            al.Add(3);
            al.Add(4);//赋值调用Add方法
            //al[5] = 5;//不能这样对集合赋值，因为集合的长度是变长的，用下标表示集合此处已确定有值，不满足集合的定义
            Console.WriteLine(al[3]);//获取值时集合加下标
            Console.WriteLine("共有元素：{0}", al.Count);//获取集合的元素个数是用al.Count
            Console.WriteLine("容量:{0}",al.Capacity );//获取集合的容量即能放元素的个数，其容量是以4、8、16来扩展容量的
            al.Remove(1);//移除元素1，移的时候只匹配第一个找到的值
            al.RemoveAt(2);//移除下标为2的元素
            al.Clear();//清空集合的元素，其容量不会改变，即内部存放的那个数组长度没变，数组没有重新分配
         
            Console.WriteLine(al.Contains(2));//确定某元素是否在集合al中，是则返回ture，否则false           
            Console.WriteLine(al.Equals(al));//确定al是否是集合Array的一个实例，是则返回ture，否则false
            Console.WriteLine(al.GetType());//获取当前实例al的type
            al.Insert(3, 5);//将元素5插入到下标为3的集合al中,使用此方法的时候一定注意下标不能超出范围
            Console.WriteLine(al[3]);
            al.RemoveRange(1,2);//从集合中下标1开始移除2个元素
            al.Sort();//对集合中的元素进行排序          
           
            foreach (int i in al)
            {
                Console.WriteLine(i);
            }//遍历集合的元素并输出
   泛型集合：集合中数据的类型都是object，这样在为集合赋值时就回发生装箱操作。而泛型List把类型当参数，在分配内存时其数据类型已经确 定，相比集合AarryList大大地提高了性能，除此之外二者非常相像，AarryLis的一些方法List一样都适用，所以有了泛型List编程上
         一般不采用AarryList。例如：可以定义一个结构体，用它来当作集合List的类型
                
  class Program
    {
        static void Main(string[] args)
        {
      
            List<product> list = new List<product >();//定义一个泛型list，类型是product
            product pro = new product();//先实例化结构体product
            pro.name = "绿茶";//为结构体中的字段赋值
            pro.price = 3.00;
            pro.count = 10;
            list.Add(pro);//将赋值好的结构体添加到list中
            product pro1 = new product();
            pro1.name = "红茶";
            pro1.price = 3.00;
            pro1.count = 20;
            list.Add(pro1);
          
        
            Console.WriteLine(list[0].name);
       
            foreach (product i in list)
            {
                Console.WriteLine("{0}、饮料种类：{1}， 价格为{2:c}，数量为{3}",i,i.name,i.price ,i.count );
            }         
           
        }
    }
    struct product
    {
        public string name;
        public  double price;
        public  int count;
    }//定义一个结构体product，有三个字段分别是name（保存饮料名称） price（单价） count（饮料数量）
2、堆栈（Stack）：也是存放object的一个集合，只不过它是先进后出，基于堆栈的这个特点，下棋时可以用其来实现悔棋。
           
            Stack stack = new Stack();//栈，先进后出
            Console.WriteLine("元素数"+stack .Count );
            stack.Push(1);
            stack.Push(2);
            stack.Push(3);
            stack.Push(4);
            foreach (object obj in stack)
            {
                Console.WriteLine(obj);
            }
            Console .WriteLine ( stack.Pop());//将栈中最顶层的元素取出来，元素个数相应的减一
            Console.WriteLine(stack.Peek ());//只看栈中最顶层的一个元素，但不会取出元素，元素个数不会减少
            Console.WriteLine("元素数" + stack.Count);
    泛型堆栈：Stack <double> stack1= new Stack<double>();
            stack1.Push(2.3);
            stack1.Push(2.00);
            stack1.Push(3.00);
            foreach (double i in stack1)
            {
                Console.WriteLine(i);
            }
3、队列（queue）：也是存放object的一个集合，只不过它是先进先出，基于堆栈的这个特点，下棋时可以用其来实现显示下棋的整个过程。
       
            Queue queue = new Queue();//队列，先进先出
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);
            queue.Enqueue(4);
            foreach (object obj1 in queue)
            {
                Console.WriteLine(obj1);
            }
            Console.WriteLine(queue .Count );
            Console.WriteLine(queue.Peek ());//查看队列中第一个元素的值，只看不取
            Console.WriteLine(queue.Dequeue  ());//取出队列中的一个元素的值，集合中元素数减一
   泛型队列：Queue<double > qu = new Queue<double >();
            qu.Enqueue(1.00);
            qu.Enqueue(1.30);
            qu.Enqueue(1.30);
            foreach (double  a in queue)
            {
                Console.WriteLine(a);
            }

4、Hashtable：表示键/值对的集合，键必须唯一，优点：只要知道键能很快知道键中存放的值，适合存放具有唯一性的数据
          Hashtable ht = new Hashtable();
          ht.Add(1,"1111");
          ht.Add(2,"22222");
namespace ConsoleApplication3
{
    struct student
    {
        public string name;
        public int age;
    }
    class Program
    {
        static void Main(string[] args)
        {
            Hashtable ha = new Hashtable();
            ha.Add(100,new student{name="张琪",age =20});
            ha.Add(1001, new student{name="小李", age=21});
            Console.WriteLine(((student )ha[100]).name );
            foreach (object  a in ha.Keys )
            {
                Console.WriteLine(((student)ha[a]).name);
            }          
           
        }
    }
}
   泛型Hashtable：
            Dictionary<int, string> dic = new Dictionary<int, string>();
            dic.Add(1,"edjos");
            dic.Add(2, "edjos");