C#梳理【集合Collection】

C# 集合（Collection）

集合（Collection）类是专门用于数据存储和检索的类。这些类提供了对栈（stack）、队列（queue）、列表（list）和哈希表（hash table）的支持。大多数集合类实现了相同的接口。

集合（Collection）类服务于不同的目的，如为元素动态分配内存，基于索引访问列表项等等。这些类创建 Object 类的对象的集合。在 C# 中，Object 类是所有数据类型的基类。

各种集合类和它们的用法

下面是各种常用的 System.Collection 命名空间的类。

类	描述和用法
动态数组（ArrayList）	它代表了可被单独索引的对象的有序集合。 它基本上可以替代一个数组。但是，与数组不同的是，您可以使用索引在指定的位置添加和移除项目，动态数组会自动重新调整它的大小。它也允许在列表中进行动态内存分配、增加、搜索、排序各项。
哈希表（Hashtable）	它使用键来访问集合中的元素。 当您使用键访问元素时，则使用哈希表，而且您可以识别一个有用的键值。哈希表中的每一项都有一个键/值对。键用于访问集合中的项目。
排序列表（SortedList）	它可以使用键和索引来访问列表中的项。 排序列表是数组和哈希表的组合。它包含一个可使用键或索引访问各项的列表。如果您使用索引访问各项，则它是一个动态数组（ArrayList），如果您使用键访问各项，则它是一个哈希表（Hashtable）。集合中的各项总是按键值排序。
堆栈（Stack）	它代表了一个后进先出的对象集合。 当您需要对各项进行后进先出的访问时，则使用堆栈。当您在列表中添加一项，称为推入元素，当您从列表中移除一项时，称为弹出元素。
队列（Queue）	它代表了一个先进先出的对象集合。 当您需要对各项进行先进先出的访问时，则使用队列。当您在列表中添加一项，称为入队，当您从列表中移除一项时，称为出队。
点阵列（BitArray）	它代表了一个使用值 1 和 0 来表示的二进制数组。 当您需要存储位，但是事先不知道位数时，则使用点阵列。您可以使用整型索引从点阵列集合中访问各项，索引从零开始。

作为集合的补充，更多的原理和细节请参考文章：C#常用数据结构的区别 。

C#动态数组（ArrayList）

动态数组（ArrayList）代表了可被单独索引的对象的有序集合。它基本上可以替代一个数组。但是，与数组不同的是，您可以使用索引在指定的位置添加和移除项目，动态数组会自动重新调整它的大小。它也允许在列表中进行动态内存分配、增加、搜索、排序各项。

ArrayList 类的方法和属性

下表列出了 ArrayList 类的一些常用的 属性：

属性	描述
Capacity	获取或设置 ArrayList 可以包含的元素个数。
Count	获取 ArrayList 中实际包含的元素个数。
IsFixedSize	获取一个值，表示 ArrayList 是否具有固定大小。
IsReadOnly	获取一个值，表示 ArrayList 是否只读。
Item	获取或设置指定索引处的元素。

下表列出了 ArrayList 类的一些常用的 方法：

序号	方法名 & 描述
1	public virtual int Add( object value );  在 ArrayList 的末尾添加一个对象。
2	public virtual void AddRange( ICollection c );  在 ArrayList 的末尾添加 ICollection 的元素。
3	public virtual void Clear(); 从 ArrayList 中移除所有的元素。
4	public virtual bool Contains( object item );  判断某个元素是否在 ArrayList 中。
5	public virtual ArrayList GetRange( int index, int count );  返回一个 ArrayList，表示源 ArrayList 中元素的子集。
6	public virtual int IndexOf(object); 返回某个值在 ArrayList 中第一次出现的索引，索引从零开始。
7	public virtual void Insert( int index, object value );  在 ArrayList 的指定索引处，插入一个元素。
8	public virtual void InsertRange( int index, ICollection c );  在 ArrayList 的指定索引处，插入某个集合的元素。
9	public virtual void Remove( object obj );  从 ArrayList 中移除第一次出现的指定对象。
10	public virtual void RemoveAt( int index );  移除 ArrayList 的指定索引处的元素。
11	public virtual void RemoveRange( int index, int count );  从 ArrayList 中移除某个范围的元素。
12	public virtual void Reverse(); 逆转 ArrayList 中元素的顺序。
13	public virtual void SetRange( int index, ICollection c );  复制某个集合的元素到 ArrayList 中某个范围的元素上。
14	public virtual void Sort(); 对 ArrayList 中的元素进行排序。
15	public virtual void TrimToSize(); 设置容量为 ArrayList 中元素的实际个数。

ArrayList实例

下面的实例演示了动态数组（ArrayList）的概念：

using System;
using System.Collections;
 
namespace CollectionApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList al = new ArrayList();
 
            Console.WriteLine("Adding some numbers:");
            al.Add(45);
            al.Add(78);
            al.Add(33);
            al.Add(56);
            al.Add(12);
            al.Add(23);
            al.Add(9);
            
            Console.WriteLine("Capacity: {0} ", al.Capacity);
            Console.WriteLine("Count: {0}", al.Count);
                      
            Console.Write("Content: ");
            foreach (int i in al)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
            Console.Write("Sorted Content: ");
            al.Sort();
            foreach (int i in al)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Adding some numbers:
Capacity: 8
Count: 7
Content: 45 78 33 56 12 23 9
Content: 9 12 23 33 45 56 78    

C# 哈希表（Hashtable）

Hashtable 类代表了一系列基于键的哈希代码组织起来的键/值对。它使用键来访问集合中的元素。

当您使用键访问元素时，则使用哈希表，而且您可以识别一个有用的键值。哈希表中的每一项都有一个键/值对。键用于访问集合中的项目。

Hashtable 类的方法和属性

下表列出了 Hashtable 类的一些常用的 属性：

属性	描述
Count	获取 Hashtable 中包含的键值对个数。
IsFixedSize	获取一个值，表示 Hashtable 是否具有固定大小。
IsReadOnly	获取一个值，表示 Hashtable 是否只读。
Item	获取或设置与指定的键相关的值。
Keys	获取一个 ICollection，包含 Hashtable 中的键。
Values	获取一个 ICollection，包含 Hashtable 中的值。

下表列出了 Hashtable 类的一些常用的 方法：

序号	方法名 & 描述
1	public virtual void Add( object key, object value );  向 Hashtable 添加一个带有指定的键和值的元素。
2	public virtual void Clear();  从 Hashtable 中移除所有的元素。
3	public virtual bool ContainsKey( object key );  判断 Hashtable 是否包含指定的键。
4	public virtual bool ContainsValue( object value );  判断 Hashtable 是否包含指定的值。
5	public virtual void Remove( object key );  从 Hashtable 中移除带有指定的键的元素。

Hashtable实例

下面的实例演示了哈希表（Hashtable）的概念：

using System;
using System.Collections;
 
namespace CollectionsApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Hashtable ht = new Hashtable();
         ht.Add("001", "Zara Ali");
         ht.Add("002", "Abida Rehman");
         ht.Add("003", "Joe Holzner");
         ht.Add("004", "Mausam Benazir Nur");
         ht.Add("005", "M. Amlan");
         ht.Add("006", "M. Arif");
         ht.Add("007", "Ritesh Saikia");
 
         if (ht.ContainsValue("Nuha Ali"))
         {
            Console.WriteLine("This student name is already in the list");
         }
         else
         {
            ht.Add("008", "Nuha Ali");
         }
         // 获取键的集合 
         ICollection key = ht.Keys;
 
         foreach (string k in key)
         {
            Console.WriteLine(k + ": " + ht[k]);
         }
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

001: Zara Ali
002: Abida Rehman
003: Joe Holzner
004: Mausam Benazir Nur
005: M. Amlan
006: M. Arif
007: Ritesh Saikia
008: Nuha Ali 

C#排序列表（SortedList）

SortedList 类代表了一系列按照键来排序的键/值对，这些键值对可以通过键和索引来访问。

排序列表是数组和哈希表的组合。它包含一个可使用键或索引访问各项的列表。如果您使用索引访问各项，则它是一个动态数组（ArrayList），如果您使用键访问各项，则它是一个哈希表（Hashtable）。集合中的各项总是按键值排序。

SortedList 类的方法和属性

下表列出了 SortedList 类的一些常用的 属性：

属性	描述
Capacity	获取或设置 SortedList 的容量。
Count	获取 SortedList 中的元素个数。
IsFixedSize	获取一个值，表示 SortedList 是否具有固定大小。
IsReadOnly	获取一个值，表示 SortedList 是否只读。
Item	获取或设置与 SortedList 中指定的键相关的值。
Keys	获取 SortedList 中的键。
Values	获取 SortedList 中的值。

下表列出了 SortedList 类的一些常用的 方法：

序号	方法名 & 描述
1	public virtual void Add( object key, object value );  向 SortedList 添加一个带有指定的键和值的元素。
2	public virtual void Clear();  从 SortedList 中移除所有的元素。
3	public virtual bool ContainsKey( object key );  判断 SortedList 是否包含指定的键。
4	public virtual bool ContainsValue( object value );  判断 SortedList 是否包含指定的值。
5	public virtual object GetByIndex( int index );  获取 SortedList 的指定索引处的值。
6	public virtual object GetKey( int index );  获取 SortedList 的指定索引处的键。
7	public virtual IList GetKeyList();  获取 SortedList 中的键。
8	public virtual IList GetValueList();  获取 SortedList 中的值。
9	public virtual int IndexOfKey( object key );  返回 SortedList 中的指定键的索引，索引从零开始。
10	public virtual int IndexOfValue( object value );  返回 SortedList 中的指定值第一次出现的索引，索引从零开始。
11	public virtual void Remove( object key );  从 SortedList 中移除带有指定的键的元素。
12	public virtual void RemoveAt( int index );  移除 SortedList 的指定索引处的元素。
13	public virtual void TrimToSize();  设置容量为 SortedList 中元素的实际个数。

SortedList实例

下面的实例演示了排序列表（SortedList）的概念：

using System;
using System.Collections;
 
namespace CollectionsApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         SortedList sl = new SortedList();
 
         sl.Add("001", "Zara Ali");
         sl.Add("002", "Abida Rehman");
         sl.Add("003", "Joe Holzner");
         sl.Add("004", "Mausam Benazir Nur");
         sl.Add("005", "M. Amlan");
         sl.Add("006", "M. Arif");
         sl.Add("007", "Ritesh Saikia");
 
         if (sl.ContainsValue("Nuha Ali"))
         {
            Console.WriteLine("This student name is already in the list");
         }
         else
         {
            sl.Add("008", "Nuha Ali");
         }
 
         // 获取键的集合 
         ICollection key = sl.Keys;
 
         foreach (string k in key)
         {
            Console.WriteLine(k + ": " + sl[k]);
         }
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

001: Zara Ali
002: Abida Rehman
003: Joe Holzner
004: Mausam Banazir Nur
005: M. Amlan 
006: M. Arif
007: Ritesh Saikia
008: Nuha Ali

C#堆栈（Stack）

堆栈（Stack）代表了一个后进先出的对象集合。当您需要对各项进行后进先出的访问时，则使用堆栈。当您在列表中添加一项，称为推入元素，当您从列表中移除一项时，称为弹出元素。

Stack 类的方法和属性

下表列出了 Stack 类的一些常用的 属性：

属性	描述
Count	获取 Stack 中包含的元素个数。

下表列出了 Stack 类的一些常用的 方法：

序号	方法名 & 描述
1	public virtual void Clear();  从 Stack 中移除所有的元素。
2	public virtual bool Contains( object obj );  判断某个元素是否在 Stack 中。
3	public virtual object Peek(); 返回在 Stack 的顶部的对象，但不移除它。
4	public virtual object Pop(); 移除并返回在 Stack 的顶部的对象。
5	public virtual void Push( object obj ); 向 Stack 的顶部添加一个对象。
6	public virtual object[] ToArray(); 复制 Stack 到一个新的数组中。

Stack实例

下面的实例演示了堆栈（Stack）的使用：

using System;
using System.Collections;
 
namespace CollectionsApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Stack st = new Stack();
 
            st.Push('A');
            st.Push('M');
            st.Push('G');
            st.Push('W');
            
            Console.WriteLine("Current stack: ");
            foreach (char c in st)
            {
                Console.Write(c + " ");
            }
            Console.WriteLine();
            
            st.Push('V');
            st.Push('H');
            Console.WriteLine("The next poppable value in stack: {0}", 
            st.Peek());
            Console.WriteLine("Current stack: ");           
            foreach (char c in st)
            {
               Console.Write(c + " ");
            }
            Console.WriteLine();
 
            Console.WriteLine("Removing values ");
            st.Pop();
            st.Pop();
            st.Pop();
            
            Console.WriteLine("Current stack: ");
            foreach (char c in st)
            {
               Console.Write(c + " "); 
            }
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Current stack: 
W G M A
The next poppable value in stack: H
Current stack: 
H V W G M A
Removing values
Current stack: 
G M A

C#队列（Queue）

队列（Queue）代表了一个先进先出的对象集合。当您需要对各项进行先进先出的访问时，则使用队列。当您在列表中添加一项，称为入队，当您从列表中移除一项时，称为出队。

Queue 类的方法和属性

下表列出了 Queue 类的一些常用的 属性：

属性	描述
Count	获取 Queue 中包含的元素个数。

下表列出了 Queue 类的一些常用的 方法：

序号	方法名 & 描述
1	public virtual void Clear();  从 Queue 中移除所有的元素。
2	public virtual bool Contains( object obj );  判断某个元素是否在 Queue 中。
3	public virtual object Dequeue(); 移除并返回在 Queue 的开头的对象。
4	public virtual void Enqueue( object obj );  向 Queue 的末尾添加一个对象。
5	public virtual object[] ToArray(); 复制 Queue 到一个新的数组中。
6	public virtual void TrimToSize(); 设置容量为 Queue 中元素的实际个数。

Queue实例

下面的实例演示了队列（Queue）的使用：

using System;
using System.Collections;
 
namespace CollectionsApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Queue q = new Queue();
 
         q.Enqueue('A');
         q.Enqueue('M');
         q.Enqueue('G');
         q.Enqueue('W');
         
         Console.WriteLine("Current queue: ");
         foreach (char c in q)
         	Console.Write(c + " ");
         Console.WriteLine();
         q.Enqueue('V');
         q.Enqueue('H');
         Console.WriteLine("Current queue: ");         
         foreach (char c in q)
            Console.Write(c + " ");
         Console.WriteLine();
         Console.WriteLine("Removing some values ");
         char ch = (char)q.Dequeue();
         Console.WriteLine("The removed value: {0}", ch);
         ch = (char)q.Dequeue();
         Console.WriteLine("The removed value: {0}", ch);
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Current queue: 
A M G W 
Current queue: 
A M G W V H 
Removing values
The removed value: A
The removed value: M

C#点阵列（BitArray）

参考文章：C#梳理【BitArray(点阵列）】