深入解析C#常用集合：详尽分析与技巧分享

时间：11-15 现代故事提交错误

大家好，关于深入解析C#常用集合：详尽分析与技巧分享很多朋友都还不太明白，不过没关系，因为今天小编就来为大家分享关于的知识点，相信应该可以解决大家的一些困惑和问题，如果碰巧可以解决您的问题，还望关注下本站哦，希望对各位有所帮助！

ArrayList arrayList=new ArrayList();

哈希表hashTable=new Hashtable();

SortedList SortedList=new SortedList();

队列队列=new Queue();

堆栈堆栈=新堆栈（）；泛型集合（在System.Collections.Generic中）:List:动态调整大小的通用列表。Dictionary:用于存储键/值对的通用字典。SortedDictionary:基于排序的键/值对字典。Queue:通用队列。Stack:通用堆栈。 //例子

ListintList=new List();

Dictionarydictionary=new Dictionary();

QueuedoubleQueue=新队列();

StackcharStack=new Stack();其他常见的泛型集合：HashSet:用于存储唯一元素的无序集合。LinkedList:双向链表。Queue:先进先出队列。Stack:LIFO 堆栈。ObservableCollection:实现了INotifyCollectionChanged 接口，可用于实现数据绑定集合。 //例子

HashSetuniqueSet=new HashSet();

LinkedListfloatList=new LinkedList();

QueuedateTimeQueue=new Queue();

StackboolStack=new Stack();

ObservableCollectionobservableCollection=new ObservableCollection();

泛型集合非泛型集合比较

以Queue和Queue的区别为案例进行描述在C# 中，Queue 和Queue 分别表示非通用和通用队列数据结构。它们之间的主要区别如下：元素类型：Queue 是非泛型的，可以存储任何类型的对象，但使用时需要进行类型转换。 Queue 是通用的，可以直接指定队列中元素的类型，提供类型安全的操作。类型安全：队列不提供类型安全，因为它可以存储任何类型的对象。队列提供类型安全，编译器可以在编译时检查元素的类型。语法：队列操作需要使用Enqueue和Dequeue方法，使用元素时需要进行类型转换。 Queue的语法更加直观，可以直接使用泛型类型进行操作，例如Enqueue和Dequeue。推荐使用：在现代C#编程中，通常建议使用泛型集合类（例如Queue）以获得更好的类型安全性和性能。非泛型队列主要用于与遗留代码互操作或者需要互操作COM（组件对象模型）等非泛型API时。下面通过一个例子演示Queue和Queue的基本用法：

//使用非通用队列

队列非通用队列=new Queue();

nonGenericQueue.Enqueue("Item1");

nonGenericQueue.Enqueue("Item2");

对象dequeuedItem=nonGenericQueue.Dequeue();

//使用泛型QueueQueuegenericQueue=new Queue();

genericQueue.Enqueue("Item1");

genericQueue.Enqueue("Item2");

字符串genericDequeuedItem=genericQueue.Dequeue();总的来说，如果您正在编写新代码，建议使用泛型集合类，因为它们提供更好的类型安全性和性能。

二：集合分析使用示例

HashTable：在C# 中，System.Collections 命名空间中的HashTable 类提供了用于存储键/值对的基本哈希表数据结构。但是，请注意，在较新的.NET 版本中，HashTable 类已被Dictionary 类取代，因为后者提供了更多功能并且性能更好。因此，建议使用Dictionary，除非你必须使用旧代码或特定要求的HashTable。这是使用HashTable 的基本示例：

使用系统；

使用系统集合；

班级计划

{

静态无效Main()

{

//创建一个新的HashTable实例

哈希表hashtable=new Hashtable();

//添加键值对

hashtable.Add("key1", "value1");

hashtable.Add("key2", "value2");

hashtable.Add("key3", "value3");

//通过键获取值

string valueForKey2=(string)hashtable["key2"];

Console.WriteLine("key2: 的值" + valueForKey2);

//检查是否包含特定键

if (hashtable.ContainsKey("key1"))

{

Console.WriteLine("哈希表包含key1");

}

//检查是否包含特定值

if (hashtable.ContainsValue("value3"))

{

Console.WriteLine("哈希表包含value3");

}

//删除键值对

hashtable.Remove("key3");

//遍历所有键值对

foreach（哈希表中的DictionaryEntry条目）

{

Console.WriteLine("Key:"+entry.Key+",Value:"+entry.Value);

}

请注意，Hashtable中存储的键和值都是对象类型，因此获取值时需要进行类型转换。

如前所述，如果您使用的是较新版本的.NET，建议使用Dictionary 而不是HashTable。这是使用字典的相同功能的示例：

使用系统；

使用System.Collections.Generic；

班级计划

{

静态无效Main()

{

//创建一个新的字典实例

Dictionarydictionary=new Dictionary();

//添加键值对

字典.Add("key1", "value1");

字典.Add("key2", "value2");

字典.Add("key3", "value3");

//通过键获取值

字符串valueForKey2=字典["key2"];

Console.WriteLine("key2: 的值" + valueForKey2);

//检查是否包含特定键

if (字典.ContainsKey("key1"))

{

Console.WriteLine("字典包含key1");

}

//检查是否包含特定值

if (dictionary.ContainsValue("value3"))

{

Console.WriteLine("字典包含value3");

}

//删除键值对

字典.删除("key3");

//遍历所有键值对

foreach（字典中的var kvp）

{

Console.WriteLine("Key:" + kvp.Key + ", Value:" + kvp.Value);

}

}使用Dictionary更加类型安全，并提供更多功能，例如LINQ查询。

SortedList和SortedList：在C# 中，SortedList 和SortedList 都表示键/值对的有序集合，但它们有一些重要的区别。元素类型：SortedList是非泛型的，可以存储任何类型的键和值。 SortedList 是通用的，可以指定特定类型的键和值。类型安全：SortedList 不提供类型安全，因为它可以存储任何类型的对象。 SortedList提供类型安全，编译器可以在编译时检查键和值的类型。泛型的性能和效率：SortedList 在处理值类型时通常比非泛型SortedList 更高效，因为它避免了装箱和拆箱的开销。使用方式：使用SortedList时，使用元素时需要进行类型转换。使用SortedList时，可以直接使用泛型类型进行操作，更加方便。语法：SortedList操作需要使用Add和Remove方法，使用元素时需要进行类型转换。 SortedList的语法更加直观，可以直接使用泛型类型进行操作，如Add、Remove等。这是使用这两个类的示例：

//使用非泛型SortedList

SortedList nonGenericSortedList=new SortedList();

nonGenericSortedList.Add("key3", "value3");

nonGenericSortedList.Add("key1", "value1");

nonGenericSortedList.Add("key2", "value2");

//需要类型转换

字符串nonGenericValueForKey2=(string)nonGenericSortedList["key2"];

//使用泛型SortedListSortedListgenericSortedList=new SortedList();

genericSortedList.Add("key3", "value3");

genericSortedList.Add("key1", "value1");

genericSortedList.Add("key2", "value2");

//不需要类型转换

字符串genericValueForKey2=genericSortedList["key2"];总的来说，如果您正在编写新代码，通常建议使用泛型集合类以获得更好的类型安全性和性能。非泛型集合类可用于需要与遗留代码互操作或需要与非泛型API（例如COM（组件对象模型））互操作的情况。

注意要实现自定义比较器类MyCustomComparer，您需要创建一个类并实现IComparer接口。 IComparer 接口定义了一种用于比较两个对象的方法，返回一个指示它们相对顺序的整数。

这是一个简单的示例，展示了如何创建自定义比较器类：

使用系统；

使用系统集合；

//自定义比较器类

公共类MyCustomComparer : IComparer

{

公共int 比较（对象x，对象y）

{

//在这里定义你的比较逻辑

//返回负数表示x小于y

//返回零表示x 等于y

//返回一个正数，表示x大于y

//在这个例子中，我们假设x和y是字符串类型

字符串strX=x 作为字符串；

字符串strY=y 作为字符串；

if (strX==null || strY==null)

{

throw new ArgumentException("对象不是字符串类型");

}

//使用默认的字符串比较器进行比较

返回string.Compare(strX, strY, StringComparison.CurrentCulture);

}

班级计划

{

静态无效Main()

{

//创建一个新的SortedList 并使用自定义比较器

SortedList SortedList=new SortedList(new MyCustomComparer());

//添加键值对

SortedList.Add("key3", "value3");

SortedList.Add("key1", "value1");

SortedList.Add("key2", "value2");

//遍历所有键值对

foreach（sortedList 中的DictionaryEntry 条目）

{

Console.WriteLine("Key:"+entry.Key+",Value:"+entry.Value);

}

在上面的代码中，MyCustomComparer 类实现了IComparer 接口的Compare 方法，该方法定义了如何比较两个对象。在本例中，我们比较两个字符串，并使用默认的字符串比较器进行比较。您可以根据需要修改比较逻辑。

请注意，在创建SortedList 时，通过将MyCustomComparer 实例传递给构造函数，我们告诉SortedList 使用我们定义的比较器来决定键的顺序。

Queue和Stack队列和堆栈是两种不同类型的数据结构，分别代表先进先出（FIFO）队列和后进先出（LIFO）堆栈。它们的比较如下：

Queue:

先进先出（FIFO）：元素按照添加到队列的顺序进行处理，先添加的元素先删除。Enqueue 操作：将一个元素添加到队列末尾。Dequeue 操作：从队列头部删除一个元素。Peek 操作：查看头部元素，但不要将其删除。

Stack:

后进先出（LIFO）：元素按照添加到堆栈的顺序进行处理，最后添加的元素首先被删除。Push 操作：将元素推入栈顶。Pop 操作：从堆栈顶部弹出一个元素。Peek 操作：查看栈顶元素而不移除它。

共同点：

泛型：Queue 和Stack 都是可以存储指定类型元素的通用类。

如何选择：

使用场景：如果需要按照先进先出的顺序处理元素，请选择队列。如果需要按照后进先出的顺序处理元素，请选择堆栈。

操作：如果需要在两端执行操作，或者需要随机访问元素，则可能需要考虑其他数据结构，例如列表。

使用示例：

//使用QueueQueuequeue=new Queue();

队列.Enqueue("Item1");

队列.Enqueue("Item2");

字符串dequeuedItem=queue.Dequeue();

//使用StackStackstack=new Stack();

stack.Push("Item1");

stack.Push("Item2");

字符串poppedItem=stack.Pop();简而言之，选择使用队列还是堆栈取决于您的具体需求。如果您需要以不同的顺序处理元素，或者进行不同的操作，请选择适合您的场景的数据结构。

HashSet：HashSet 是C# 中表示集合的通用类，它提供了存储和检索唯一元素的有效方法。以下是HashSet的基本使用示例：using System;

使用System.Collections.Generic；

班级计划

{

静态无效Main()

{

//创建一个新的HashSet实例

HashSethashSet=new HashSet();

//添加元素

hashSet.Add("Item1");

hashSet.Add("Item2");

hashSet.Add("Item3");

//添加重复元素（不会生成重复项）

hashSet.Add("Item2");

//检查是否包含特定元素

bool containsItem=hashSet.Contains("Item1");

Console.WriteLine("HashSet 包含Item1: " + containsItem);

//删除元素

bool returnedItem=hashSet.Remove("Item3");

Console.WriteLine("已删除的Item3: " + returnedItem);

//遍历所有元素

Console.WriteLine("HashSet elements:");

foreach（hashSet 中的var 项）

{

Console.WriteLine(项目);

}

//清空集合

hashSet.Clear();

}

上面的代码中，我们首先创建了一个HashSet类型的实例，然后使用Add方法添加元素，使用Contains方法检查元素是否存在，使用Remove方法删除元素，使用foreach遍历所有元素，最后使用Clear方法清除集合。

HashSet的优点是它提供了O(1)复杂度的元素查找，因为它使用哈希表来实现。这使得它非常适合需要快速查找和唯一性的场景。使用时，请确保元素类型T 实现适当的GetHashCode 和Equals 方法，以确保集合正常工作。

需要注意的是，HashSet 是无序的，并且元素的顺序并不按照它们添加到集合中的顺序存储。如果您需要有序集合，请考虑使用其他集合类型，例如SortedSet 或List。

LinkedList：LinkedList是C#中的泛型类，表示双向链表。它允许在集合中进行高效的插入和删除操作，并提供元素的双向迭代。下面是LinkedList的基本使用示例：using System;

使用System.Collections.Generic；

班级计划

{

静态无效Main()

{

//创建一个新的LinkedList实例

LinkedListlinkedList=new LinkedList();

//将元素添加到链表末尾

linkedList.AddLast("Item1");

linkedList.AddLast("Item2");

linkedList.AddLast("Item3");

//向链表头部添加一个元素

linkedList.AddFirst("Item0");

//遍历链表中的所有元素

Console.WriteLine("LinkedList 元素(向前):");

foreach（linkedList 中的var item）

{

Console.WriteLine(项目);

}

//遍历链表中的所有元素（逆向）

Console.WriteLine("nLinkedList 元素(向后):");

var lastNode=linkedList.Last;

while (lastNode !=null)

{

Console.WriteLine(最后一个节点

.Value); lastNode = lastNode.Previous; } // 在指定节点后插入新元素 LinkedListNodenode = linkedList.Find("Item1"); linkedList.AddAfter(node, "New Item After Item1"); // 在指定节点前插入新元素 linkedList.AddBefore(node, "New Item Before Item1"); // 删除指定元素 linkedList.Remove("Item2"); // 删除指定节点 linkedList.Remove(node); // 遍历最终链表 Console.WriteLine("nFinal LinkedList elements:"); foreach (var item in linkedList) { Console.WriteLine(item); } } }在上述代码中，我们首先创建了一个LinkedList类型的实例，然后使用AddLast和AddFirst方法在链表尾部和头部添加元素。我们使用foreach循环正向和反向遍历链表中的所有元素。接着，我们演示了在指定节点后、前插入新元素，以及删除指定元素和节点的操作。需要注意的是，LinkedList提供了对链表中节点的直接访问，通过LinkedListNode类型可以访问节点的前一个和后一个节点。这使得在链表中执行插入和删除操作更为灵活。 LinkedList在以下情况下可以是一个合适的选择：频繁的插入和删除操作：如果你的应用程序需要频繁地执行插入和删除操作，而不仅仅是在集合的两端进行操作，LinkedList可能比其他集合类型（如List）更适合。由于链表结构的特性，插入和删除操作的开销是 O(1)。需要双向迭代：如果你需要在集合中进行双向迭代（即同时访问前一个和后一个元素），LinkedList提供了直接的支持。你可以通过LinkedListNode类型访问节点的前一个和后一个节点，从而实现双向迭代。不需要按索引访问元素：LinkedList不支持按照索引直接访问元素，而是需要通过节点的方式进行访问。如果你的代码中不需要按照索引访问元素，而是通过迭代访问元素，LinkedList可以是一个合适的选择。内存分配和释放较为灵活：由于链表是动态分配的，插入和删除操作不需要像数组那样涉及到元素的移动。这使得LinkedList在某些情况下可以更灵活地管理内存。元素需要唯一：如果你需要确保集合中的元素是唯一的，LinkedList提供了AddLast,AddBefore,AddAfter,AddFirst等方法来确保元素的唯一性。