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)的概念:

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

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

                                                                                  1. Adding some numbers:
                                                                                    1. Capacity: 8
                                                                                      1. Count: 7
                                                                                        1. Content: 45 78 33 56 12 23 9
                                                                                          1. 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)的概念:

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

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

                                                                                                                                                                  1. 001: Zara Ali
                                                                                                                                                                    1. 002: Abida Rehman
                                                                                                                                                                      1. 003: Joe Holzner
                                                                                                                                                                        1. 004: Mausam Benazir Nur
                                                                                                                                                                          1. 005: M. Amlan
                                                                                                                                                                            1. 006: M. Arif
                                                                                                                                                                              1. 007: Ritesh Saikia
                                                                                                                                                                                1. 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)的概念:

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

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

                                                                                                                                                                                                                                                          1. 001: Zara Ali
                                                                                                                                                                                                                                                            1. 002: Abida Rehman
                                                                                                                                                                                                                                                              1. 003: Joe Holzner
                                                                                                                                                                                                                                                                1. 004: Mausam Banazir Nur
                                                                                                                                                                                                                                                                  1. 005: M. Amlan
                                                                                                                                                                                                                                                                    1. 006: M. Arif
                                                                                                                                                                                                                                                                      1. 007: Ritesh Saikia
                                                                                                                                                                                                                                                                        1. 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)的使用:

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

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

                                                                                                                                                                                                                                                                                                                                                                    1. Current stack:
                                                                                                                                                                                                                                                                                                                                                                      1. W G M A
                                                                                                                                                                                                                                                                                                                                                                        1. The next poppable value in stack: H
                                                                                                                                                                                                                                                                                                                                                                          1. Current stack:
                                                                                                                                                                                                                                                                                                                                                                            1. H V W G M A
                                                                                                                                                                                                                                                                                                                                                                              1. Removing values
                                                                                                                                                                                                                                                                                                                                                                                1. Current stack:
                                                                                                                                                                                                                                                                                                                                                                                  1. 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)的使用:

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

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                C#点阵列(BitArray)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                参考文章:C#梳理【BitArray(点阵列)】

                                                                                                                                                                                                                                                                                                                                                                                                                                                                C#梳理【集合Collection】的更多相关文章

                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. Guava库介绍之集合(Collection)相关的API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  作者:Jack47 转载请保留作者和原文出处 欢迎关注我的微信公众账号程序员杰克,两边的文章会同步,也可以添加我的RSS订阅源. 本文是我写的Google开源的Java编程库Guava系列之一,主要介 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                2. 【再探backbone 02】集合-Collection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  前言 昨天我们一起学习了backbone的model,我个人对backbone的熟悉程度提高了,但是也发现一个严重的问题!!! 我平时压根没有用到model这块的东西,事实上我只用到了view,所以昨 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                3. 5、数组和集合--Collection、Map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  一.数组:同一个类型数据的集合,其实他也是一个容器 1.数组的好处:可以自动给数组中的元素从0开始编号,方便操作这些数据 2.数组的定义: 在Java中常见: 格式1:  类型 [] 数组名 = ne ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                4. WCF分布式开发步步为赢(8):使用数据集(DataSet)、数据表(DataTable)、集合(Collection)传递数据

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  数据集(DataSet).数据表(DataTable).集合(Collection)概念是.NET FrameWork里提供数据类型,在应用程序编程过程中会经常使用其来作为数据的载体,属于ADO.NE ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                5. 在含有null值的复杂类的集合(Collection)中取最大值

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  在日常编程中,经常遇到要在一组复杂类的集合(Collection)中做比较.取最大值或最小值. 举个最简单的例子,我们要在一个如下结构的集合中选取包含最大值的元素: public class Clas ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                6. 集合Collection总览

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  前言 声明,本文使用的是JDK1.8 从今天开始正式去学习Java基础中最重要的东西--->集合 无论在开发中,在面试中这个知识点都是非常非常重要的,因此,我在此花费的时间也是很多,得参阅挺多的 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                7. java中集合Collection转list对象

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  参考:java中集合Collection转list对象 首先我的需求是获取到购物车列表,购物车列表是一个Map对象,构造方法获取购物项,这里购物项是Collection对象 // 购物项集合,K商品I ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                8. java基础27 单例集合Collection及其常用方法

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1.集合 集合是存储对象数据的集合容器 1.1.集合比数组的优势 1.集合可以存储任意类型的数据,数组只能存储同一种数据类型的数据    2.集合的长度是变化的,数组的长度是固定的 1.2.数组:存储 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                9. 18_java之集合Collection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  01集合使用的回顾 *A:集合使用的回顾 *a.ArrayList集合存储5个int类型元素 public static void main(String[] args) { ArrayList< ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                10. 集合--Collection接口详解&&迭代器

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /* * 集合的顶层接口--Collection接口 * 添加 * add() * addAll() * * 遍历集合 * iterator() 迭代器 * * 删除 * remove() * rem ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                随机推荐

                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. React Router 4.0 基本使用

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  路由的概念,起初来源于服务端,就是当浏览器访问一个网站的不同页面时,服务端能够正确的返回页面的内容.当访问首页时,它能返回首页的内容,访问关于我们页面时,返回关于我们的内容.可以看到路由就是一种控制和 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                2. poj-1724(bfs+优先队列)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  题意:有向图,给你m条边,每条边有两个权值,路径长和通过这条路径的花费,问你在不超过k花费的前提下,最短的路径从1走到n 解题思路:因为边数很少,我们可以直接用暴力每条边的方式来找最小的路径长,也就是 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                3. 利用random模块生成验证码

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  random模块 该模块用于数学或者数据相关的领域,使用方法非常简单下面介绍常用的放法 1.随机小数 random.random() 2.随机整数random.randint(1,5) # 大于等于1 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                4. python 机械学习之sklearn的数据正规化

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  from sklearn import preprocessing    #导入sklearn的处理函数用于处理一些大值数据 x_train, x_test, y_train, y_test = tr ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                5. 微信小程序——引入背景图片【六】

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  前言 之前写了一些小程序的博文只是看文档边看边写,了解下他,这次可是真枪真刀的做了! 框架使用的是美团的mpvue,我也是一边学习,一边写的,如有错误之处,还望大家指出. 在这里我有个问题,为什么微信 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                6. .net mvc 基类属性覆盖问题

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  一,问题是这样的 我使用.net mvc设计架构时, 为了方便大家的获取UserInfo信息, 把UserInfo对象,放在了自定义的基类BaseController中, 二,问题出现了 我发觉多个人 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                7. ContOS 常用命令

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  文件与目录操作 命令 解析 cd /home 进入 ‘/home’ 目录 cd .. 返回上一级目录 cd ../.. 返回上两级目录 cd - 返回上次所在目录 cp file1 file2 将fi ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                8. Matplotlib学习---用matplotlib画误差线(errorbar)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  误差线用于显示数据的不确定程度,误差一般使用标准差(Standard Deviation)或标准误差(Standard Error). 标准差(SD):是方差的算术平方根.如果是总体标准差,那么用σ表 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                9. 直接使用security.basic.path无效|——springboot2.0以上的security的配置

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  问题 springcloud 版本 为 Finchley.RELEASEspringboot 版本为 2.0.3.RELEASE 现在有需求,/swagger-ui.html 页面需要添加登录认证,但 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                10. 「2017 Multi-University Training Contest 1」2017多校训练1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1001 Add More Zero(签到题) 题目链接 HDU6033 Add More Zero 找出最大的k,使得\(2^m-1\ge 10^k\). 直接取log,-1可以忽略不计. #inc ...