C# 集合类总结

我们用的比较多的非泛型集合类主要有 ArrayList 类 和 HashTable 类。我们经常用 HashTable 来存储将要写入到数据库或者返回的信息，在这之间要不断的进行类型的转化，增加了系统装箱和拆箱的负担，如果我们操纵的数据类型相对确定的化 用 Dictionary<TKey,TValue> 集合类来存储数据就方便多了，例如我们需要在电子商务网站中存储用户的购物车信息 ( 商品名，对应的商品个数 ) 时，完全可以用 Dictionary<string, int> 来存储购物车信息，而不需要任何的类型转化。

 

1. 数组是固定大小的，不能伸缩。虽然 System.Array.Resize 这个泛型方法可以重置数组大小，

 

但是该方法是重新创建新设置大小的数组，用的是旧数组的元素初始化。随后以前的数组就废弃！而集合却是可变长的

 

2. 数组要声明元素的类型，集合类的元素类型却是 object.

 

3. 数组可读可写不能声明只读数组。集合类可以提供 ReadOnly 方法以只读方式使用集合。

 

4. 数组要有整数下标才能访问特定的元素，然而很多时候这样的下标并不是很有用。集合也是数据列表却不使用下标访问。

 

很多时候集合有定制的下标类型，对于队列和栈根本就不支持下标访问！

 

1.       数组

 

int[] intArray1;

// 初始化已声明的一维数组

intArray1 = new int[3];

intArray1 = new int[3]{1,2,3};

intArray1 = new int[]{1,2,3};

 

2.  ArrayList 类对象被设计成为一个动态数组类型，其容量会随着需要而适当的扩充方法

 

1 ： Add() 向数组中添加一个元素，

2 ： Remove() 删除数组中的一个元素

3 ： RemoveAt(int i) 删除数组中索引值为 i 的元素

4 ： Reverse() 反转数组的元素

5 ： Sort() 以从小到大的顺序排列数组的元素

6 ： Clone() 复制一个数组

 

using System;

using System.Collections.Generic;

using System.Text;

using System.Collections;

 

namespace ConsoleApplication1

{

     class Program

      {

         static void Main(string[] args)

          {

             ArrayList al = new ArrayList();

             al.Add(100);// 单个添加

               foreach (int number in new int[6] { 9, 3, 7, 2, 4, 8 })

              {

                 al.Add(number);// 集体添加方法一 // 清清月儿 http://blog.csdn.net/21aspnet/

             }

              int[] number2 = new int[2] { 11,12 };

             al.AddRange(number2);// 集体添加方法二

             al.Remove(3);// 移除值为 3 的

             al.RemoveAt(3);// 移除第 3 个

             ArrayList al2 = new ArrayList(al.GetRange(1, 3));// 新 ArrayList 只取旧 ArrayList 一部份

 

             Console.WriteLine(" 遍历方法一 :");

             foreach (int i in al)// 不要强制转换

              {

                 Console.WriteLine(i);// 遍历方法一

             }

             Console.WriteLine(" 遍历方法二 :");

             for (int i = 0; i != al2.Count; i++)// 数组是 length

              {

                 int number = (int)al2[i];// 一定要强制转换

                 Console.WriteLine(number);// 遍历方法二

              }

         }

     }

  }

 

3.       List

可通过索引访问的对象的强类型列表。提供用于对列表进行搜索、排序和操作的方法 , 在决定使用 List 还是使用 ArrayList 类（两者具有类似的功能）时，记住 List 类在大多数情况下执行得更好并且是类型安全的。如果对 List 类的类型 T 使用引用类型，则两个类的行为是完全相同的。但是，如果对类型 T 使用值类型，则需要考虑实现和装箱问题。

 

如果对类型 T 使用值类型，则编译器将特别针对该值类型生成 List 类的实现。这意味着不必对 List 对象的列表元素进行装箱就可以使用该元素，并且在创建大约 500 个列表元素之后，不对列表元素装箱所节省的内存将大于生成该类实现所使用的内存。

 

// 声明一个 List 对象，只加入 string 参数

List<string> names = new List<string>();

names.Add(" 乔峰 ");

names.Add(" 欧阳峰 ");

names.Add(" 马蜂 ");

// 遍历 List

foreach (string name in names)

{

Console.WriteLine(name);

}

 

// 向 List 中插入元素

names.Insert(2, " 张三峰 ");

 

// 移除指定元素

names.Remove(" 马蜂 ");

 

4. Dictionary

表示键和值的集合。 Dictionary 遍历输出的顺序，就是加入的顺序，这点与 Hashtable 不同

Dictionary<string, string> myDic = new Dictionary<string, string>();

myDic.Add("aaa", "111");

myDic.Add("bbb", "222");

myDic.Add("ccc", "333");

myDic.Add("ddd", "444");

 

// 如果添加已经存在的键， add 方法会抛出异常

     try

       {

         myDic.Add("ddd","ddd");

     }

     catch (ArgumentException ex)

       {

          Console.WriteLine(" 此键已经存在： " + ex.Message);

     }

 

     // 解决 add() 异常的方法是用 ContainsKey() 方法来判断键是否存在

     if (!myDic.ContainsKey("ddd"))

       {

         myDic.Add("ddd", "ddd");

     }

     else

       {

         Console.WriteLine(" 此键已经存在： ");

     }

 

      // 而使用索引器来负值时，如果建已经存在，就会修改已有的键的键值，而不会抛出异常

     myDic ["ddd"]="ddd";

     myDic["eee"] = "555";

 

     // 使用索引器来取值时，如果键不存在就会引发异常

     try

       {

         Console.WriteLine(" 不存在的键 ""fff"" 的键值为： " + myDic["fff"]);

     }

     catch (KeyNotFoundException ex)

        {

         Console.WriteLine(" 没有找到键引发异常： " + ex.Message);

     }

 

     // 解决上面的异常的方法是使用 ContarnsKey() 来判断时候存在键，如果经常要取健值得化最好用 TryGetValue 方法来获取集合中的对应键值

 

     string value = "";

     if (myDic.TryGetValue("fff", out value))

       {

         Console.WriteLine(" 不存在的键 ""fff"" 的键值为： " + value );

     }

     else

       {   

         Console.WriteLine(" 没有找到对应键的键值 ");

     }

 

     // 下面用 foreach 来遍历键值对

     // 泛型结构体 用来存储健值对

     foreach (KeyValuePair<string, string> kvp in myDic)

       {

         Console.WriteLine("key={0},value={1}", kvp.Key, kvp.Value);

     }

 

     // 获取值得集合

     foreach (string s in myDic.Values)

       {

         Console.WriteLine("value={0}", s);

     }

 

     // 获取值得另一种方式

     Dictionary<string, string>.ValueCollection values = myDic.Values;

     foreach (string s in values)

       {

         Console.WriteLine("value={0}", s);

     }

 

常用的属性和方法如下     

	常用属性	属性说明
	Comparer	获取用于确定字典中的键是否相等的 IEqualityComparer 。
	Count	获取包含在 Dictionary 中的键 / 值对的数目。
	Item	获取或设置与指定的键相关联的值。
	Keys	获取包含 Dictionary 中的键的集合。
	Values	获取包含 Dictionary 中的值的集合。
	常用的方法	方法说明
	Add	将指定的键和值添加到字典中。
	Clear	从 Dictionary 中移除所有的键和值。
	ContainsKey	确定 Dictionary 是否包含指定的键。
	ContainsValue	确定 Dictionary 是否包含特定值。
	Equals	已重载。 确定两个 Object 实例是否相等。 （从 Object 继承。）
	GetEnumerator	返回循环访问 Dictionary 的枚举数。
	GetHashCode	用作特定类型的哈希函数。 GetHashCode 适合在哈希算法和数据结构（如哈希表）中使用。 （从 Object 继承。）
	GetObjectData	实现 System.Runtime.Serialization.ISerializable 接口，并返回序列化 Dictionary 实例所需的数据。
	GetType	获取当前实例的 Type 。 （从 Object 继承。）
	OnDeserialization	实现 System.Runtime.Serialization.ISerializable 接口，并在完成反序列化之后引发反序列化事件。
	ReferenceEquals	确定指定的 Object 实例是否是相同的实例。 （从 Object 继承。）
	Remove	从 Dictionary 中移除所指定的键的值。
	ToString	返回表示当前 Object 的 String 。 （从 Object 继承。）
	TryGetValue	获取与指定的键相关联的值。

 

5.       SortedList 类

与哈希表类似，区别在于 SortedList 中的 Key 数组排好序的

 

//SortedList

 

System.Collections.SortedList list=new System.Collections.SortedList();

list.Add("key2",2);

list.Add("key1",1);

for(int i=0;i<list.Count;i++)

{

System.Console.WriteLine(list.GetKey(i));

}

 

 

6.Hashtable 类

 

哈希表 ， 名 - 值对。类似于字典 ( 比数组更强大 ) 。哈希表是经过优化的，访问下标的对象先散列过。如果以任意类型键值访问其中元素会快于其他集合。

 

GetHashCode() 方法返回一个 int 型数据，使用这个键的值生成该 int 型数据。哈希表获取这个值最后返回一个索引，表示带有给定散列的数据项在字典中存储的位置。

 

Hashtable 和 Dictionary <K, V> 类型

  1 ：单线程程序中推荐使用 Dictionary, 有泛型优势 , 且读取速度较快 , 容量利用更充分 .

  2 ：多线程程序中推荐使用 Hashtable, 默认的 Hashtable 允许单线程写入 , 多线程读取 , 对 Hashtable 进一步调用 Synchronized() 方法可以获得完全线程安全的类型 . 而 Dictionary 非线程安全 , 必须人为使用 lock 语句进行保护 , 效率大减 .

  3 ： Dictionary 有按插入顺序排列数据的特性 ( 注 : 但当调用 Remove() 删除过节点后顺序被打乱 ), 因此在需要体现顺序的情境中使用 Dictionary 能获得一定方便 .

 

HashTable 中的 key/value 均为 object 类型，由包含集合元素的存储桶组成。存储桶是 HashTable 中各元素的虚拟子组，与大多数集合中进行的搜索和检索相比，存储桶可令搜索和检索更为便捷。每一存储桶都与一个哈希代码关联，该哈希代码是使用哈希函数生成的并基于该元素的键。 HashTable 的优点就在于其索引的方式，速度非常快。如果以任意类型键值访问其中元素会快于其他集合，特别是当数据量特别大的时候，效率差别尤其大。

 

HashTable 的应用场合有：做对象缓存，树递归算法的替代，和各种需提升效率的场合。

 

    //Hashtable sample

    System.Collections.Hashtable ht = new System.Collections.Hashtable();

    //--Be careful: Keys can't be duplicated, and can't be null----

    ht.Add(1, "apple");

    ht.Add(2, "banana");

    ht.Add(3, "orange");   

    //Modify item value:

    if(ht.ContainsKey(1))

        ht[1] = "appleBad";

    //The following code will return null oValue, no exception

    object oValue = ht[5];    

    //traversal 1:

    foreach (DictionaryEntry de in ht)

    {

        Console.WriteLine(de.Key);

        Console.WriteLine(de.Value);

    }

    //traversal 2:

    System.Collections.IDictionaryEnumerator d = ht.GetEnumerator();

    while (d.MoveNext())

    {

        Console.WriteLine("key ： {0} value ： {1}", d.Entry.Key, d.Entry.Value);

    }

    //Clear items

    ht.Clear();

 

 

Dictionary 和 HashTable 内部实现差不多，但前者无需装箱拆箱操作，效率略高一点。

 

    //Dictionary sample

    System.Collections.Generic.Dictionary<int, string> fruits =          new System.Collections.Generic.Dictionary<int, string>();

    fruits.Add(1, "apple");

    fruits.Add(2, "banana");

    fruits.Add(3, "orange");

    foreach (int i in fruits.Keys)

    {

        Console.WriteLine("key ： {0} value ： {1}", i, fruits);     }

 

    if (fruits.ContainsKey(1))

    {

        Console.WriteLine("contain this key.");

    }

 

 

HashTable 是经过优化的，访问下标的对象先散列过，所以内部是无序散列的，保证了高效率，也就是说，其输出不是按照开始加入的顺序，而 Dictionary 遍历输出的顺序，就是加入的顺序，这点与 Hashtable 不同。如果一定要排序 HashTable 输出，只能自己实现：

 

    //Hashtable sorting

    System.Collections.ArrayList akeys = new System.Collections.ArrayList(ht.Keys); //from Hashtable

    akeys.Sort(); //Sort by leading letter

    foreach (string skey in akeys)

    {

        Console.Write(skey + ":");

        Console.WriteLine(ht[skey]);

    }

 

HashTable 与线程安全：

 

为了保证在多线程的情况下的线程同步访问安全，微软提供了自动线程同步的 HashTable:

如果 HashTable 要允许并发读但只能一个线程写 , 要这么创建 HashTable 实例 :

 

    //Thread safe HashTable

    System.Collections.Hashtable htSyn = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());

 

这样 , 如果有多个线程并发的企图写 HashTable 里面的 item, 则同一时刻只能有一个线程写 , 其余阻塞 ; 对读的线程则不受影响。

 

另外一种方法就是使用 lock 语句，但要 lock 的不是 HashTable ，而是其 SyncRoot ；虽然不推荐这种方法，但效果一样的，因为源代码就是这样实现的 :

 

//Thread safe

private static System.Collections.Hashtable htCache = new System.Collections.Hashtable ();

 

public static void AccessCache ()

{

    lock ( htCache.SyncRoot )

    {

        htCache.Add ( "key", "value" );

 

        //Be careful: don't use foreach to operation on the whole collection

        //Otherwise the collection won't be locked correctly even though indicated locked

        //--by MSDN

    }

}

 

 

//Is equivalent to 等同于 (lock is equivalent to Monitor.Enter and Exit()

public static void AccessCache ()

{

    System.Threading.Monitor.Enter ( htCache.SyncRoot );

 

    try

    {

        /* critical section */

        htCache.Add ( "key", "value" );

 

        //Be careful: don't use foreach to operation on the whole collection

        //Otherwise the collection won't be locked correctly even though indicated locked

        //--by MSDN

    }

    finally

    {

        System.Threading.Monitor.Exit ( htCache.SyncRoot );

    }

}

 

7. Stack 类

栈，后进先出。 push 方法入栈， pop 方法出栈。

 

System.Collections.Stack stack=new System.Collections.Stack();

stack.Push(1);

stack.Push(2);

 

System.Console.WriteLine(stack.Peek());

while(stack.Count>0)

{

System.Console.WriteLine(stack.Pop());

}

 

8.Queue 类

队列，先进先出。 enqueue 方法入队列， dequeue 方法出队列。

 

System.Collections.Queue queue=new System.Collections.Queue();

queue.Enqueue(1);

queue.Enqueue(2);

 

System.Console.WriteLine(queue.Peek());

while(queue.Count>0)

{

System.Console.WriteLine(queue.Dequeue());

}