谈谈Dictionary和List的问题

引子：

事情的起因我已经记不清了，但是事情的根本原因在于，我们要遍历一个集合，是用字典来存储还是用数组链表来存储。

1.       把基本概念说清

对List<T>的阐述，我在http://www.cnblogs.com/kym/archive/2009/03/09/1406657.html一文中已经有过相应的解释，再此不再赘述。

Dictionary<T1,T2>，我们俗称其为字典，他包含一个Key和与之对应的Value，其目的是能够根据Key迅速地找到Value，算法复杂度为O(1)。

2.       Dictionary<T1,T2>和Hashtable的异同

首先很多人都认同一个观点，说Dictionary<T1,T2>是HashTable的泛型版本，这一点在大致上是正确的，可是当我们运行这样一段代码时，便可看出他们的不同：

代码

 1              Dictionary < int ,  int >  dic  =   new  Dictionary < int ,  int > ();
 2              dic.Add( 1 ,  5 );
 3              dic.Add( 10 ,  3 );
 4              dic.Add( 2 ,  5 );
 5               foreach  ( int  key  in  dic.Keys)
 6              {
 7                  Console.WriteLine(key);
 8              }
 9 
10              Hashtable hashtable  =   new  Hashtable();
11              hashtable.Add( 1 ,  5 );
12              hashtable.Add( 10 ,  3 );
13              hashtable.Add( 2 ,  5 );
14               foreach  ( object  key  in  hashtable.Keys)
15              {
16                  Console.WriteLine(key.ToString());
17              }

 

 

Dictionary<T1,T2>是根据插入的顺序来遍历，但是Hashtable在插入时会打乱其位置。

并且我们在用Reflector看源码的时候也会发现

代码

 1  if  (( this .buckets[num6].key  ==   null )  ||  (( this .buckets[num6].key  ==   this .buckets)  &&  (( this .buckets[num6].hash_coll  &   0x80000000L )  ==   0L )))
 2      {
 3           if  (index  !=   - 1 )
 4          {
 5              num6  =  index;
 6          }
 7          Thread.BeginCriticalRegion();
 8           this .isWriterInProgress  =   true ;
 9           this .buckets[num6].val  =  nvalue;
10           this .buckets[num6].key  =  key;
11           this .buckets[num6].hash_coll  |=  ( int ) num3;
12           this .count ++ ;
13           this .UpdateVersion();
14           this .isWriterInProgress  =   false ;
15          Thread.EndCriticalRegion();
16      }
17   

Hashtable是线程安全的，而Dictionary明显不具备如此特性。

3.       Dictionary<T1,T2>的存储原理

说到字典，我们就不能不说其存储结构，他会根据Key通过Hash计算来得到其应存放的虚拟内存地址，这也是在哈希表中Key必须唯一的原因，当我们按照Key进行查找时，首先就是根据Key计算出其所存放的虚拟内存地址，去对应的内存地址找数据，得到其Value。

这一点HashTable与其相同。

4.       问题提出

我们为了讨论遍历时Dictionary和List的效率，我写了这样一段测试代码：

代码

 1              Dictionary < string ,  string >  dic  =   new  Dictionary < string ,  string > ();
 2              Random r  =   new  Random();
 3               for  ( int  i  =   0 ; i  <   100000 ; i ++ )
 4              {
 5                   int  random  =  r.Next( 10 );
 6                  dic.Add(i.ToString(), random.ToString());
 7              }
 8              StringBuilder sb  =   new  StringBuilder( 10000000 );
 9              Stopwatch sw  =   new  Stopwatch();
10              sw.Start();
11               foreach  ( string  key  in  dic.Keys)
12              {
13                  sb.Append(dic[key]);
14              }
15              sw.Stop();
16              Console.WriteLine( " Dic花费的时间: " );
17              Console.WriteLine(sw.ElapsedTicks.ToString());
18              GC.Collect();
19 
20              List < string >  list  =   new  List < string > ();
21               for  ( int  i  =   0 ; i  <   100000 ; i ++ )
22              {
23                  list.Add(r.Next().ToString());
24              }
25 
26              sb  =   new  StringBuilder( 10000000 );
27              sw.Reset();
28              sw.Start();
29 
30               foreach  ( string  s  in  list)
31              {
32                  sb.Append(s);
33              }
34 
35              sw.Stop();
36              Console.WriteLine( " List花费的时间: " );
37              Console.WriteLine(sw.ElapsedTicks.ToString());

 

 

这段代码产生的测试结果如下：

 

5.       问题剖析

同样是集合，为什么性能会有这样的差距。我们要从存储结构和操作系统的原理谈起。

首先我们清楚List<T>是对数组做了一层包装，我们在数据结构上称之为线性表，而线性表的概念是，在内存中的连续区域，除了首节点和尾节点外，每个节点都有着其唯一的前驱结点和后续节点。我们在这里关注的是连续这个概念。

而HashTable或者Dictionary，他是根据Key而根据Hash算法分析产生的内存地址，因此在宏观上是不连续的，虽然微软对其算法也进行了很大的优化。

由于这样的不连续，在遍历时，Dictionary必然会产生大量的内存换页操作，而List只需要进行最少的内存换页即可，这就是List和Dictionary在遍历时效率差异的根本原因。

6.       再谈Dictionary

也许很多人说，既然Dictionary如此强大，那么我们为什么不用Dictionary来代替一切集合呢？

在这里我们除了刚才的遍历问题，还要提到Dictionary的存储空间问题，在Dictionary中，除了要存储我们实际需要的Value外，还需要一个辅助变量Key，这就造成了内存空间的双重浪费。

而且在尾部插入时，List只需要在其原有的地址基础上向后延续存储即可，而Dictionary却需要经过复杂的Hash计算，这也是性能损耗的地方。

7.       任何方法都要合理使用

我在之前的文章中，如:从Dynamic到特性误用.曾无数次强调过，方法可以用，但每个方法都有着其存在的意义，我们调用这个方法，或者使用某个类，数据结构前，一定要搞清其存在的意义，其优点和缺点，这样我们才能写出最好的代码。