C#2.0--集合

集合在编程的过程中用的是非常的多，如GridViewRowCollection、ConnectionStringSettingsCollection、NameValueCollection等等。一般来说，集合的类都包含在System.Collections命名空间中。那众多集合之间又有什么样的联系呢？这需要我们从集合的集成关系上理顺一下。

 

一、IEnumerable和IEnumerator接口
    IEnumberable接口是大部分集合类型的根。它是一个支持foreach迭代的接口，一个集合对象要能遍历所有对象的话，那它必需要实现这个接口，它的声明结构如下：
        public interface IEnumerable
        {
            IEnumerator GetEnumerator ();
        }
    其中的GetEnumerator方法返回的是IEnumerator类型，可以用返回的IEnumerator类型结果实现对集合内容的向前遍历。
    IEnumerator接口的声明如下：
       public interface IEnumerator
       {
            Object Current { get; }     //获取集合中的当前元素。
            bool MoveNext ();             //如果枚举成功推进到下一个元素，则为 true；如果枚举数越过集合的结尾，则为 false。
            void Reset () ;                    //将枚举数设置为其初始位置，该位置位于集合中第一个元素之前。    
       }
    如在HashTable中用IEnumerator遍历数据（关于Hashtable后面会有介绍）：
        Hashtable h = new Hashtable();
        h.Add("a","aaaa");
        h.Add("b", "bbbb");
        IEnumerator ie = h.GetEnumerator();
        while (ie.MoveNext())
        {
            Console.Write(((DictionaryEntry)ie.Current).Key + "\t" + ((DictionaryEntry)ie.Current).Value+"\n");
        }
      
二、ICollection接口
    ICollection接口派生自IEnumerable接口，扩展了集合元素个数和同步功能(对多线程安全访问的支持)。
    ICollection接口的声明：
       public interface ICollection : IEnumerable
       {
            int Count { get; }          //ICollection集合中元素的个数
            bool IsSynchronized { get; }   //获取是否同步对ICollection 的访问。
            Object SyncRoot { get; }     //获取用于同步ICollection访问的对象。
       }         
       所有实现ICollection接口的对象，可以在对集合元素遍历的时候，把集合锁定，以防其它线程（用户）对集合的修改。
        ArrayList al = new ArrayList();
        al.Add("aaa");
        al.Add("bbb");
        lock (al.SyncRoot)
        {
            for(int i=0;i<al.Count;i++)
            {
                Console.WriteLine(obj);
            }
        }
    ICollection接口派生了IDictionary和IList两个子接口。
三、IList接口
    IList是一个值的集合，派生自ICollection，其成员可以通过索引访问。如ArrayList
    IList接口的声明：
        public interface IList : ICollection, IEnumerable
        {
            int Add(object value);      //将某项添加到IList集合中
            void Clear ();      //从 IList 中移除所有项。
            bool Contains (Object value);    //确定 IList 是否包含特定值。
            int IndexOf (Object value); //取得IList集合中指定项的索引号。
            void Insert (int index,Object value); //将一个项插入IList集合的指定索引处。
            void Remove(object value);   //从IList集合中移除指定的项对象。
            void RemoveAt(int index); //从IList集合中移除指定索引项的对象。
            bool IsFixedSize { get; } //指示IList 是否具有固定大小。大小固定的集合在创建之后不允许添加或移除元素，但允许修改现有元素。
            bool IsReadOnly { get; } //IList 是否为只读。只读集合在创建之后不允许添加、移除或修改元素。
            Object this [int index] { get; set; } //获取或设置指定索引号元素的内容。可以使用此索引器实现集合元素的循环遍历。
        }
      
      
四、IDictionary接口
    IDictionary接口实现一个“键/值”对的集合，派生自ICollection，可以用循环遍历其中的每一个元素。其中的每个"键/值"对是一个DictionaryEntry 对象，只能用键名来存取对象，不能用索引号来存取对象。如HashTable
    iDictionary接口的声明：
        public interface IDictionary : ICollection, IEnumerable
        {
            void Add (Object key,Object value); //在IDictionary集合中添加键和值对元素。
            void Clear ();      //从 IList 中移除所有项。
            bool Contains (Object value);    //确定 IList 是否包含特定值。
            IDictionaryEnumerator GetEnumerator (); //返回一个用于 IDictionary 集合的 IDictionaryEnumerator 对象。
            void Remove (Object key);     //从集合中移除指定键值的元素
            bool IsFixedSize { get; } //指示IList 是否具有固定大小。大小固定的集合在创建之后不允许添加或移除元素，但允许修改现有元素。
            bool IsReadOnly { get; } //IList 是否为只读。只读集合在创建之后不允许添加、移除或修改元素。
           Object this [Object key] { get; set; } //获取或设置具有指定键的元素。
            ICollection Keys { get; } //获取IDictionary中的所有的键集合。
            ICollection Values { get; }   //获取IDictionary中的所有的值集合。
        }

五、ArrayList类
    ArrayList类实现了IList接口，用来存储非泛型对象。
        Count属性：集合中实际元素的个数。
        Capacity属性：ArrayList空间的大小。生成一个ArrayList对象的时候默认分配了4个元素的空间(默认)，在添加前4个元素的时候Capacity始终是4。当添加第5个元素的时候，首先框架会把ArrayList的Capacity的容量加倍，然后再把第5个元素存入。
        void AddRange (ICollection c)：将一个新的ICollection对象加到当前ArrayList后面，通常用来拼接两个ArrayList。
        ArrayList GetRange (int index,int count)：从当前的ArrayList对象中返回指定位置和指定数目的元素，并将这些元素以新的ArrayList对象形式返回。
        void InsertRange(int index,ICollection c) ：在指定的位置插入另一个ICollection对象。
        void TrimToSize()：将ArrayList的容量缩减到ArrayList的实际的元素个数。
        void Reverse() ：将数组的顺序进行返转。
        void Sort()：将数组进行排序。
      
六、Hashtable类：
    Hashtable实现了IDictionary接口，可以用来存储非泛型对象。由于Hashtable实现的是IEnumerable接口，所以可以用foreach对Hashtable进行遍历。
        void ContainsKey(object o)   //判断Hashtable 是否包含指定键。
        void ContainsValue(object o)    //判断Hashtable是否包含指定的值。
        Hashtable Hashtable.Synchronized (Hashtable t) //静态方法，将一个普通的Hashtable包装为一个同步的(线程安全)Hashtable。
    用IEnumerator对Hashtable进行显示：
        Hashtable h = new Hashtable();
        h.Add("a","aaaa");
        h.Add("b", "bbbb");
        IEnumerator ie = h.GetEnumerator();
        while (ie.MoveNext())
        {
            Console.Write(((DictionaryEntry)ie.Current).Key + "\t" + ((DictionaryEntry)ie.Current).Value+"\n");
        }
    用foreach来实现对Hashtable的迭代显示：
        Hashtable h = new Hashtable();
        h.Add("a","aaa");
        h.Add("b", "bbb");
        foreach (DictionaryEntry d in h)
        {
            Console.WriteLine(d.Key+"\t"+d.Value);
        }
    由于Keys和Values也是ICollection集合，所以也要以用foreach分别对Keys和Values集合进行迭代
        Hashtable h = new Hashtable();
        h.Add("a","aaa");
        h.Add("b", "bbb");    
        foreach (object var in h.Keys)
        {
            Console.WriteLine(var);
        }
        foreach (object var in h.Values)
        {
            Console.WriteLine(var);
        }  
      
七、SortedList类：
    SortedList与散列表一样也是一个"键/值"对的集合，但它是按照关键字进行排序的，其值是可以通过数字索引来处理。  
             object GetKey(int index)：//根据索引号来取得指定位置的键。
             object GetByIndex(int index)：//根据索引号来取得指定位置的值。
             IList GetKeyList()：//获取SortedList中的键的集合。
             IList GetValueList()：//获取SortedList中的值的集合。
             object IndexOfKey(object var)：//取出SortedList中指定键的索引号。
             object IndexOfValue(object var)：//取出SortedList中指定值的索引号。
           
    用索引号遍历SortedList中的每个元素
            SortedList h = new SortedList();
            h.Add("a","aaa");
            h.Add("d","ddd");
            h.Add("f", "fff");
            h.Add("e", "eee");
            h.Add("c","ccc");
            h.Add("b", "bbb");            
            for (int i = 0; i < h.Count; i++)
            {
                Console.WriteLine(h.GetByIndex(i)+"\t"+h.GetKey(i));
            }
       从输出的结果中，我们会发现其中的元素会按照key的顺序进行排序的。
       GetKeyList()和GetValueList()返回的都是IList类型的数据，所以我们也可以使用foreach对二者的返回结果进行迭代：
            SortedList h = new SortedList();
            h.Add("a","aaa");
            h.Add("d","ddd");
            h.Add("f", "fff");
            h.Add("e", "eee");
            h.Add("c","ccc");
            h.Add("b", "bbb");
            foreach (object var in h.GetKeyList())
            {
                Console.WriteLine(var);
            }
            foreach (object var in h.GetValueList())
            {
                Console.WriteLine(var);
            }
          
八、Queue类和Stack类
    这两个类都实现了ICollection接口和IEnumerable接口，但没有实现IList接口。
    Queue：队列，先进先出。
        Enqueue(object var)：入队
        object Dequeue() ：出队
        object Peek()：返回队首的元素，但不移除
       出队和入队都分影响Queue对象的元素的个数，即影响其Count属性。
            Queue q = new Queue();
            q.Enqueue("aaa");
            q.Enqueue("bbb");
            q.Enqueue("ccc");
            for (int i = 0; i < 3; i++) //这里用的是i<3而不是i<q.Count，因为Dequeue的过程中会影响q.Count。
            {
                Console.WriteLine(q.Dequeue());
            }
           
    Stack：堆栈，先进后出。
        Push(object var)： //进栈
        object Pop() ： //出栈
        object Peek()： //返回栈顶元素，但不移除
        入栈和出栈都会影响Stack的元素个数。
            Stack s = new Stack();
            s.Push("aaa");
            s.Push("bbb");
            s.Push("ccc");
            for (int i = 0; i < 3; i++) //这里用的是i<3而不是i<s.Count，因为Pop的过程中会影响s.Count。
            {
                Console.WriteLine(s.Peek());
            }
          
九、ListDictionary类、HybridDictionary类和StringDictionary类
    这三个类都实现了IDictionary接口，属于System.Collections.Specialized 命名空间。
    ListDictionary类对于10个或10个以下集合元素的性能非常高，但对于元素个数很大的集合性能欠佳。
    HybridDictonary类在集合较小时，使用 ListDictionary 来实现 IDictionary，然后当集合变大时，切换到 Hashtable。
    StringDictonary类是一个键和值都是强类型化为字符串的散列表。
    这三个类和Hashtable一样，既可以用foreach进行迭代也可以用IEnumerator进行遍历。       

十、StringCollection类
    实现了IList接口，System.Collections.Specialized 命名空间。
    类似于只包含字符串的、强类型化的ArrayList。可以通过Foreach迭代，通过数字索引访问。

十一、NameValueCollection类
    类似于有序的字符串值和字符串键的集合，它并没实现IDictionary接口。
        string[] AllKeys属性：所有键的字符串数组。
        bool HasKeys()：集合对象中是否包含"键/值"对。
        string Get(int index/string key)：根据索引号或键名来取得元素的值。
        string GetKey(int index)：根据索引号取得键名。
      
       对NameValueCollection集合对象的遍历：
            NameValueCollection nvc = new NameValueCollection();
            nvc.Add("a", "aaa");
            nvc.Add("b","bbb");
            nvc.Add("c","ccc");
            foreach (string s in nvc.AllKeys)
            {
                Console.WriteLine(nvc[s].ToString());
            }

转载于:https://www.cnblogs.com/30ErLi/archive/2010/09/17/1828968.html