C#非泛型集合类与泛型集合类的区别 （转）

来自：http://blog.csdn.net/jiayanhui2877/article/details/7623845

C# 泛型集合之非泛型集合类与泛型集合类的对应：

ArrayList对应List

HashTable对应Dictionary

Queue对应Queue

Stack对应Stack

SortedList对应SortedList

 

C# 集合类 Array Arraylist List Hashtable Dictionary Stack Queue
1.数组是固定大小的，不能伸缩。虽然System.Array.Resize这个泛型方法可以重置数组大小，
但是该方法是重新创建新设置大小的数组，用的是旧数组的元素初始化。随后以前的数组就废弃！而集合却是可变长的
2.数组要声明元素的类型，集合类的元素类型却是object.
3.数组可读可写不能声明只读数组。集合类可以提供ReadOnly方法以只读方式使用集合。
4.数组要有整数下标才能访问特定的元素，然而很多时候这样的下标并不是很有用。集合也是数据列表却不使用下标访问。
很多时候集合有定制的下标类型，对于队列和栈根本就不支持下标访问！ 
 

ArrayList 是数组的复杂版本。ArrayList 类提供在大多数 Collections 类中提供但不在 Array 类中提供的一些功能。例如：

Array 的容量是固定的，而 ArrayList 的容量是根据需要自动扩展的。如果更改了 ArrayList.Capacity 属性的值，则自动进行内存重新分配和元素复制。
ArrayList 提供添加、插入或移除某一范围元素的方法。在 Array 中，您只能一次获取或设置一个元素的值。
使用 Synchronized 方法可以很容易地创建 ArrayList 的同步版本。而 Array 将一直保持它直到用户实现同步为止。
ArrayList 提供将只读和固定大小包装返回到集合的方法。而 Array 不提供。
另一方面，Array 提供 ArrayList 所不具有的某些灵活性。例如：

可以设置 Array 的下限，但 ArrayList 的下限始终为零。
Array 可以具有多个维度，而 ArrayList 始终只是一维的。
特定类型（不包括 Object）的 Array 的性能比 ArrayList 好，这是因为 ArrayList 的元素属于 Object 类型，所以在存储或检索值类型时通常发生装箱和取消装箱。
要求一个数组的大多数情况也可以代之以使用 ArrayList。它更易于使用，并且通常具有与 Object 类型的数组类似的性能。

Array 位于 System 命名空间中；ArrayList 位于 System.Collections 命名空间中。

//数组
int[] intArray1;
//初始化已声明的一维数组
intArray1 = new int[3];
intArray1 = new int[3]{1,2,3};
intArray1 = new int[]{1,2,3};



//ArrayList类对象被设计成为一个动态数组类型，其容量会随着需要而适当的扩充
方法
1：Add()向数组中添加一个元素，
2：Remove()删除数组中的一个元素
3：RemoveAt(int i)删除数组中索引值为i的元素
4：Reverse()反转数组的元素
5：Sort()以从小到大的顺序排列数组的元素
6：Clone()复制一个数组 

 //ArrayList动态数组 定义 赋值 输出  ArrayList可以不用指定维数 可动态赋值  赋不同类型值
            ArrayList arrayList1 = new ArrayList();
            arrayList1.
            arrayList1.Add("a");
            arrayList1.Add(1);
            arrayList1.Add("b");
            Response.Write(arrayList1[1]);

   //Array数组类 所有数组的基类 定义 赋值 输出  Array的容量是固定的，先指定大小再赋值            

Array arrayList2 = Array.CreateInstance(typeof(string), 6);
            arrayList2.SetValue("a", 0);
            arrayList2.SetValue("b", 1);
            Response.Write(arrayList2.GetValue(1));

   

   //哈希表
           

 Hashtable abc = new Hashtable();
            abc.Add("1", "34");
            if (abc.Contains("1"))
            {
                Response.Write(abc["1"]);
            }

 //List 

可通过索引访问的对象的强类型列表。提供用于对列表进行搜索、排序和操作的方法在决定使用 List 还是使用 ArrayList 类（两者具有类似的功能）时，记住 List 类在大多数情况下执行得更好并且是类型安全的。如果对 List 类的类型 T 使用引用类型，则两个类的行为是完全相同的。但是，如果对类型 T 使用值类型，则需要考虑实现和装箱问题。 
如果对类型 T 使用值类型，则编译器将特别针对该值类型生成 List 类的实现。这意味着不必对 List 对象的列表元素进行装箱就可以使用该元素，并且在创建大约 500 个列表元素之后，不对列表元素装箱所节省的内存将大于生成该类实现所使用的内存。
//Dictionary 
表示键和值的集合。Dictionary遍历输出的顺序，就是加入的顺序，这点与Hashtable不同 
//SortedList类 
 与哈希表类似，区别在于SortedList中的Key数组排好序的 
//Hashtable类 
 哈希表，名-值对。类似于字典(比数组更强大)。哈希表是经过优化的，访问下标的对象先散列过。如果以任意类型键值访问其中元素会快于其他集合。 
GetHashCode()方法返回一个int型数据，使用这个键的值生成该int型数据。哈希表获取这个值最后返回一个索引，表示带有给定散列的数据项在字典中存储的位置。 
//Stack类 
 栈，后进先出。push方法入栈，pop方法出栈。 
Queue类 
 队列，先进先出。enqueue方法入队列，dequeue方法出队列。 


------------------------------------------------------------- 

//Dictionary 
 System.Collections.DictionaryEntry dic=new System.Collections.DictionaryEntry("key1","value1"); 

 Dictionary<int, string> fruit = new Dictionary<int, string>(); 

 //加入重复键会引发异常 
fruit.Add(1, "苹果"); 
fruit.Add(2, "桔子"); 
fruit.Add(3, "香蕉"); 
fruit.Add(4, "菠萝"); 

 //因为引入了泛型，所以键取出后不需要进行Object到int的转换，值的集合也一样 
foreach (int i in fruit.Keys) 
 { 
 Console.WriteLine("键是：{0} 值是：{1}",i,fruit); 
 } 
 //删除指定键，值 
fruit.Remove(1); 
 //判断是否包含指定键 
if (fruit.ContainsKey(1)) 
 { 
 Console.WriteLine("包含此键"); 
 } 
 //清除集合中所有对象 
fruit.Clear(); 
 } 

 //ArrayList 
 System.Collections.ArrayList list=new System.Collections.ArrayList(); 
 list.Add(1); 
 list.Add(2); 
 for(int i=0;i<list.Count;i++) 
 { 
 System.Console.WriteLine(list[i]); 
 } 

 //List 
 //声明一个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("马蜂");

 //HashTable 
 System.Collections.Hashtable table=new System.Collections.Hashtable(); 
 table.Add("table1",1); 
 table.Add("table2",2); 
 System.Collections.IDictionaryEnumerator d=table.GetEnumerator(); 
 while(d.MoveNext()) 
 { 
 System.Console.WriteLine(d.Entry.Key); 
 } 

 //Queue 
 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()); 
 } 

 //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)); 
 } 

 //Stack 
 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()); 
 }