C# 集合与泛型

1、什么是集合

集合类时为保障数据的安全存储和访问设计的，常见的集合类如下：

ArrayList  使用大小可按需动态增加的数组实现System.Collections.Ilist 接口。

SortedList  表示键/值对的集合，这些键/值对按键排序并可按照键和索引访问。

Queue  表示对象的先进先出集合。

Stack  表示对象简单的后进先出集合。

HashTable  表示键/值对的集合，这些键/值对根据键的哈希代码进行组织。

集合类实现的接口如下：

Icollection  定义所有非泛型集合的大小，枚举数和同步方法。

Icomparer  公开一种比较两个对象的方法。

IEnumerable  公开枚举数，该枚举数支持杂器在非泛型集合上进行简单迭代。

IList  表示可按照对象单独访问的非泛型集合。

IDictionary  表示键/值对的非通用集合。

IDictionaryEnumerator  枚举非泛型字典的元素。

 2、SortedList 可排序数组集合

SortedList 集合的初始化方式有两种，包括泛型的和非泛型的。

SortedList s1 = new SortedList();   //创建非泛型SortedList 集合
SortedList<Tkey, Tvalue> s1 = new SortedList<Tkey, Tvalue>(); //创建泛型SortedList 集合

private static void KeyandValueOut(SortedList s1)
        {
            Console.WriteLine("\t-键-\t-值-");
            for (int i = 0; i < s1.Count; i++)
            {
                Console.WriteLine("\t{0}:\t{1}", s1.GetKey(i), s1.GetByIndex(i)); //获取每个元素的键和值
            }
        }
        static void Main(string[] args)
        {
            SortedList s1 = new SortedList();   //创建非泛型SortedList 可排序数组
            s1.Add(1, "you");
            s1.Add(2, "me");
            s1.Add(3, "him");
            Console.WriteLine("SortedList 里的元素共{0}个", s1.Count); //输出SortedList 的元素个数
            Console.WriteLine("容量：" + s1.Capacity);
            KeyandValueOut(s1);  //遍历输出SortedList 所有的键及其对应的值
            Console.ReadKey();
        }

3、 Queue 消息队列集合

同 SortedList 集合一样，Queue 队列也有两种初始化方式。

Queue q = new Queue();    //创建非泛型队列

Queue<T> q = new Queue<T>();  //泛型队列

static void Main(string[] args)
        {
            Queue q = new Queue(); //创建队列
            q.Enqueue("I");     //给队列添加元素
            q.Enqueue("love");
            q.Enqueue("peace");
            q.Enqueue("!");
            IEnumerator myEnumerator = q.GetEnumerator(); //实例化能循环访问队列枚举数 IEnumerator 接口
            Console.WriteLine("该队列中的所有元素如下所示。");
            while (myEnumerator.MoveNext())
            {
                Console.Write(myEnumerator.Current + " "); //获取队列中的全部元素
            }
            Console.WriteLine();
            q.Peek();   //返回队列的开始处但不移除
            q.Dequeue();  //移除并返回开始处
            Console.WriteLine("将某元素踢出队列后剩余的元素如下所示。");
            IEnumerator myEnumerator1 = q.GetEnumerator();
            while (myEnumerator1.MoveNext())
            {
                Console.Write(myEnumerator1.Current + " ");
            }
            Console.WriteLine();
            if (q.Contains("love") == true)
            {
                Console.WriteLine("该队列包含 love 元素");
            }
            else
            {
                Console.WriteLine("该队列不包含 love 元素");
            }
            q.Clear(); //移除所有对象
            Console.WriteLine("该队列所含元素总数为：" + q.Count);
            Console.ReadKey();
        }

3、 Stack 栈集合

和前两种集合类一样，Stack 栈也有两种初始化方式，非泛型和泛型。

Stack st = new Stack();  //非泛型堆栈

Stack<T> st = new Stack<T>();  //泛型堆栈

static void Main(string[] args)
        {
            Stack st = new Stack();  //创建堆栈集合
            st.Push('a');           //将a,b,c,d,e压入栈
            st.Push('b');
            st.Push('c');
            st.Push('d');
            st.Push('e');
            Console.WriteLine("堆栈中的元素共有：{0}", st.Count);
            IEnumerator myEnumerator = st.GetEnumerator();  //实例化能遍历访问堆栈中所有元素的 IEnumerator 接口
            Console.WriteLine("堆栈中的所有元素如下所示。");
            while (myEnumerator.MoveNext())
            {
                Console.Write(myEnumerator.Current + " ");  //把堆栈中所有元素输出到控制台
            }
            st.Pop();  //将第一个元素弹出堆栈
            IEnumerator myEnumerator1 = st.GetEnumerator();
            Console.WriteLine();
            Console.WriteLine("某元素弹出后堆栈中的剩余元素如下所示。");
            while (myEnumerator1.MoveNext())
            {
                Console.Write(myEnumerator1.Current + " ");
            }
            Console.WriteLine();
            Console.ReadKey();
        }

4、HashTable 哈希表集合

与前面的三种集合不同的是，.NET Framework 本身没有对HashTable 提供泛型，所以它的初始化方式只有一种。

HashTable ht = new HashTable();   //创建哈希表集合

public static void PrintKeysAndValues(Hashtable myHT)
        {
            foreach (string s in myHT.Keys)
            {
                Console.WriteLine(s);
            }
            Console.WriteLine(" -键- -值-");
            //HashTable 中的每个元素都是键/值对，即不是键的类型，也不是值的类型，
            //而是DictionaryEntry 类型
            foreach (DictionaryEntry de in myHT)
            {
                Console.WriteLine(" {0}:{1}", de.Key, de.Value);
            }
            Console.WriteLine();
        }
        static void Main(string[] args)
        {
            Hashtable ht = new Hashtable();  //创建哈希表集合
            ht.Add("Ea", "a");
            ht.Add("Ab", "b");
            ht.Add("Cc", "c");
            ht.Add("Bd", "d");
            Console.WriteLine("Hashtable 表中的所有元素的键如下：");
            PrintKeysAndValues(ht);   //遍历输出HashTable中的所有键/值对
            ArrayList a1 = new ArrayList(ht.Keys);
            a1.Sort();  //将HashTable中的元素按键的首字母排序
            foreach (string key in a1)
            {
                Console.Write("键：" + key);  //输出键
                Console.WriteLine("值：" + ht[key]);  //输出键对应的值
            }
            Console.ReadKey();
        }