概念

描述

示例代码

集合的定义

集合是C#中用于存储和操作一组相关数据的类，集合类型提供了灵活的存储和动态调整大小的能力，且支持存储不同类型的对象。

List<int> numbers = new List<int>(); HashSet<string> names = new HashSet<string>(); Dictionary<int, string> dict = new Dictionary<int, string>();

ArrayList

ArrayList 是一个非泛型集合，适合存储不同类型的对象，但不支持类型安全，现代C#中多用List<T>替代。

ArrayList list = new ArrayList(); list.Add(1); list.Add("Hello");

List

List<T>是最常用的集合类型，类似于数组，但可以动态调整大小，适合存储有序的数据，支持通过索引访问元素。

List<int> numbers = new List<int> { 1, 2, 3 }; numbers.Add(4); int firstNumber = numbers[0];

HashSet

HashSet<T>用于存储唯一的元素集合，不允许重复元素，适合用于快速查找、去重等操作。

HashSet<string> names = new HashSet<string> { "Alice", "Bob", "Charlie" }; names.Add("Alice"); bool exists = names.Contains("Alice");

Dictionary

Dictionary<TKey, TValue>用于存储键值对的集合，通过键快速查找对应的值，适合用于需要通过键快速访问数据的场景。

Dictionary<int, string> dict = new Dictionary<int, string> { { 1, "One" }, { 2, "Two" } }; string value = dict[1];

Queue

Queue<T>是先进先出（FIFO）集合，适合用于需要按顺序处理元素的场景，如任务队列。

Queue<string> queue = new Queue<string>(); queue.Enqueue("Task1"); string nextTask = queue.Dequeue();

Stack

Stack<T>是后进先出（LIFO）集合，适合用于需要逆序处理元素的场景，如撤销操作。

Stack<int> stack = new Stack<int>(); stack.Push(1); int topElement = stack.Pop();

集合的动态扩展

集合可以自动调整大小，添加新元素时无需手动管理存储空间，不像数组需要预先定义大小。

List<int> numbers = new List<int>(); numbers.Add(10);

集合中的元素操作

集合类型提供丰富的操作方法，如添加、删除、查找、排序等，使用起来比数组更灵活和强大。

List<int> numbers = new List<int> { 3, 1, 2 }; numbers.Sort(); numbers.Remove(1);

多种集合类型选择

C#提供了多种集合类型，适用于不同的使用场景，如List用于顺序存储，HashSet用于去重，Dictionary用于键值对存储等。

选择List来存储有序数据，选择Dictionary来通过键快速查找，选择HashSet来存储唯一值的集合。

概念

描述

示例代码

ArrayList的定义

ArrayList是一个非泛型集合类，可以存储任意类型的对象，但不提供类型安全和性能优化。

ArrayList list = new ArrayList(); list.Add(1); list.Add("Hello");

动态调整大小

ArrayList可以动态调整大小，随着元素的添加或删除，ArrayList会自动调整其容量。

list.Add(42); list.Add("world");

访问元素

可以通过索引访问ArrayList中的元素，但需要显式转换为具体的类型，这容易导致运行时错误。

int number = (int)list[0]; string text = (string)list[1];

类型安全性问题

由于ArrayList存储的是对象类型，因此需要在取出元素时进行类型转换，缺乏类型安全，容易出现类型转换异常。

list.Add(3.14); double pi = (double)list[2];

元素的添加与删除

ArrayList支持动态添加和删除元素，但在删除时同样需要显式转换为正确的类型。

list.Remove("Hello"); list.RemoveAt(0);

性能问题

由于ArrayList是非泛型集合，存储的是object类型，频繁的装箱和拆箱操作会导致性能开销，因此在现代C#开发中已不推荐使用。

int sum = 0; foreach (int num in list) { sum += num; }

常见的操作

ArrayList提供了常见的集合操作，如添加、删除、查找、插入等，但由于类型不安全，使用这些操作时需要特别小心。

list.Insert(1, "Inserted Value"); bool contains = list.Contains("Hello");

与泛型集合的比较

与List<T>等泛型集合相比，ArrayList缺乏类型安全，性能较低，因此在现代C#开发中已逐渐被泛型集合替代。

List<int> numbers = new List<int>(); numbers.Add(10);

概念

描述

示例代码

Hashtable的定义

Hashtable 是C#中一种非泛型的键值对集合，允许通过键快速查找对应的值，键和值都可以是任意类型的对象。

Hashtable hashtable = new Hashtable();

存储键值对

Hashtable 通过哈希函数将键映射到存储桶中，因此可以快速查找、添加和删除元素。

hashtable.Add("key1", "value1"); hashtable["key2"] = 42;

访问元素

通过键访问Hashtable中的值，如果键不存在会返回null，需要进行类型转换。

string value = (string)hashtable["key1"]; int number = (int)hashtable["key2"];

添加和删除元素

使用Add方法添加键值对，使用索引器方式更新或添加元素，使用Remove方法删除指定键的元素。

hashtable.Remove("key1"); hashtable["key2"] = 50;

遍历Hashtable

可以使用foreach循环遍历Hashtable中的所有键值对，每个元素以DictionaryEntry对象的形式返回。

foreach (DictionaryEntry entry in hashtable) { Console.WriteLine(entry.Key + ": " + entry.Value); }

常见操作

支持检查键或值是否存在、获取键或值的集合、清空所有元素等操作，方法与Dictionary类似。

bool containsKey = hashtable.ContainsKey("key1"); hashtable.Clear();

适用场景

适用于存储键值对且不需要类型安全性的场景，特别是在需要通过键快速查找、添加或删除数据的情况下，但已被类型安全的Dictionary<TKey, TValue>取代。

Hashtable config = new Hashtable(); config.Add("Timeout", 30); config.Add("EnableLogging", true);

缺点

Hashtable 不支持类型安全，存取数据时需要进行显式类型转换，性能和类型安全性相较于Dictionary<TKey, TValue>略逊一筹。

使用Dictionary<TKey, TValue>替代以获得类型安全和更好的性能：Dictionary<string, int> dict = new Dictionary<string, int>();

概念

描述

示例代码

HashSet<T>的定义

HashSet<T> 是一种泛型集合，不允许包含重复的元素，提供快速查找、添加和删除操作，适合用于存储唯一值的场景。

HashSet<int> set = new HashSet<int>();

添加元素（Add）

使用Add方法将元素添加到HashSet中，如果元素已存在，则不会添加，并且Add方法返回false。

set.Add(10); set.Add(20);

移除元素（Remove）

使用Remove方法从HashSet中移除指定的元素，如果元素存在则移除并返回true，否则返回false。

set.Remove(10);

检查元素（Contains）

使用Contains方法检查HashSet中是否包含指定元素，适合用于快速查找。

bool exists = set.Contains(20);

遍历HashSet

可以使用foreach循环遍历HashSet中的所有元素，遍历顺序不保证与添加顺序一致。

foreach (int item in set) { Console.WriteLine(item); }

集合操作

HashSet<T> 提供集合操作方法，如UnionWith（并集）、IntersectWith（交集）、ExceptWith（差集）、SymmetricExceptWith（对称差集）等。

HashSet<int> setA = new HashSet<int> { 1, 2, 3 }; HashSet<int> setB = new HashSet<int> { 3, 4, 5 }; setA.UnionWith(setB);

适用场景

适用于需要存储唯一值并进行快速查找的场景，如去重操作、集合运算、检查唯一性等。

HashSet<string> uniqueNames = new HashSet<string>(); uniqueNames.Add("Alice"); uniqueNames.Add("Bob");

概念

描述

示例代码

Dictionary<TKey, TValue>的定义

Dictionary<TKey, TValue> 是一种键值对集合，允许你在声明时指定键和值的类型，确保类型安全，通过键快速查找对应的值，适合用于存储和检索相关数据。

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

添加键值对（Add）

使用Add方法将键值对添加到字典中，键必须是唯一的，类型安全，添加重复键会抛出ArgumentException。

dict.Add(1, "One"); dict.Add(2, "Two");

通过键访问值（索引器）

使用索引器语法通过键访问或修改字典中的值，如果键不存在会抛出KeyNotFoundException，类型安全。

string value = dict[1]; dict[2] = "Two Updated";

移除键值对（Remove）

使用Remove方法移除指定键的键值对，移除成功返回true，如果键不存在则返回false，类型安全。

dict.Remove(1);

查看键值对（TryGetValue）

使用TryGetValue方法在不抛出异常的情况下安全地获取值，适合在键可能不存在的情况下使用。

if (dict.TryGetValue(2, out string value)) { Console.WriteLine(value); }

遍历Dictionary

可以使用foreach循环遍历Dictionary中的所有键值对，遍历时每个元素以KeyValuePair<TKey, TValue>的形式返回。

foreach (var kvp in dict) { Console.WriteLine(kvp.Key + ": " + kvp.Value); }

检查键或值是否存在

使用ContainsKey或ContainsValue方法检查字典中是否存在指定的键或值，类型安全。

bool hasKey = dict.ContainsKey(1); bool hasValue = dict.ContainsValue("Two");

适用场景

适用于需要通过键快速查找值且键和值类型固定的场景，如存储配置项、缓存数据等，具有类型安全性和良好的性能。

Dictionary<string, int> scores = new Dictionary<string, int>(); scores.Add("Alice", 95); int aliceScore = scores["Alice"];

概念

描述

示例代码

Stack<T>的定义

Stack<T> 是一种后进先出（LIFO）的数据结构，允许你在声明时指定存储的数据类型，最新添加的元素最先被移除，适合处理逆序操作的场景。

Stack<int> stack = new Stack<int>();

添加元素（Push）

使用Push方法将元素添加到栈顶，每次添加都会放在栈的最上面，类型安全且避免了运行时类型转换。

stack.Push(10); stack.Push(20);

移除元素（Pop）

使用Pop方法移除并返回栈顶的元素，如果栈为空调用此方法会抛出InvalidOperationException，类型安全。

int topElement = stack.Pop();

查看栈顶元素（Peek）

使用Peek方法返回栈顶元素但不移除它，适合在不修改栈的情况下查看顶端元素，类型安全。

int topElement = stack.Peek();

遍历Stack<T>

可以使用foreach循环遍历Stack<T>中的所有元素，遍历顺序是从栈顶到栈底，类型安全。

foreach (int item in stack) { Console.WriteLine(item); }

检查是否为空

使用Count属性查看栈中的元素数量，也可以用Count == 0来判断栈是否为空。

bool isEmpty = stack.Count == 0;

常见操作

支持检查栈中元素数量（Count）、清空栈（Clear）、将栈转为数组（ToArray）等操作，类型安全。

int count = stack.Count; stack.Clear(); int[] array = stack.ToArray();

适用场景

适用于需要逆序处理特定类型数据的场景，如实现撤销操作、表达式求值、深度优先搜索等，具有类型安全性和性能优势。

Stack<string> undoStack = new Stack<string>(); undoStack.Push("Action1"); string lastAction = undoStack.Pop();

概念

描述

示例代码

Stack的定义

Stack 是一种非泛型的后进先出（LIFO）数据结构，允许存储任意类型的对象，最新添加的元素最先被移除，但缺乏类型安全性，适合处理逆序操作的场景。

Stack stack = new Stack();

添加元素（Push）

使用Push方法将任意类型的元素添加到栈顶，由于没有类型安全性，取出时需要进行类型转换。

stack.Push(10); stack.Push("Hello");

移除元素（Pop）

使用Pop方法移除并返回栈顶的元素，如果栈为空调用此方法会抛出InvalidOperationException，取出时需要进行类型转换。

int topElement = (int)stack.Pop();

查看栈顶元素（Peek）

使用Peek方法返回栈顶元素但不移除它，取出时需要进行类型转换。

string topElement = (string)stack.Peek();

遍历Stack

可以使用foreach循环遍历Stack中的所有元素，遍历顺序是从栈顶到栈底，但遍历过程中每个元素都需要进行类型转换。

foreach (object item in stack) { Console.WriteLine(item); }

检查是否为空

使用Count属性查看栈中的元素数量，也可以用Count == 0来判断栈是否为空。

bool isEmpty = stack.Count == 0;

常见操作

支持检查栈中元素数量（Count）、清空栈（Clear）、将栈转为数组（ToArray）等操作，但不具备类型安全性。

int count = stack.Count; stack.Clear(); object[] array = stack.ToArray();

适用场景

适用于存储不同类型数据且类型安全性要求不高的逆序处理场景，但在现代C#开发中通常被泛型栈Stack<T>取代。

Stack mixedStack = new Stack(); mixedStack.Push(42); mixedStack.Push("Action1"); int num = (int)mixedStack.Pop();

概念

描述

示例代码

Queue<T>的定义

Queue<T> 是一种泛型先进先出（FIFO）的数据结构，允许你在声明时指定存储的数据类型，确保类型安全，元素按照添加的顺序排列，最早添加的元素最先被移除。

Queue<int> queue = new Queue<int>();

添加元素（Enqueue）

使用Enqueue方法将元素添加到队列的末尾，类型安全且避免了运行时类型转换。

queue.Enqueue(10); queue.Enqueue(20);

移除元素（Dequeue）

使用Dequeue方法移除并返回队列的第一个元素（即最早添加的元素），如果队列为空调用此方法会抛出InvalidOperationException，类型安全。

int firstElement = queue.Dequeue();

查看队首元素（Peek）

使用Peek方法返回队列的第一个元素但不移除它，适合在不修改队列的情况下查看下一个将被移除的元素，类型安全。

int nextElement = queue.Peek();

遍历Queue<T>

可以使用foreach循环遍历Queue<T>中的所有元素，遍历顺序是从队首到队尾，类型安全。

foreach (int item in queue) { Console.WriteLine(item); }

常见操作

支持检查队列中元素数量（Count）、清空队列（Clear）、将队列转为数组（ToArray）等操作，类型安全。

int count = queue.Count; queue.Clear(); int[] array = queue.ToArray();

适用场景

适用于需要按顺序处理特定类型数据的场景，如任务队列、消息队列、打印队列、广度优先搜索等，具有类型安全性和性能优势。

Queue<string> tasks = new Queue<string>(); tasks.Enqueue("Task1"); string nextTask = tasks.Dequeue();

概念

描述

示例代码

Queue的定义

Queue 是一种非泛型先进先出（FIFO）的数据结构，允许存储任意类型的对象，但缺乏类型安全性，元素按照添加的顺序排列，最早添加的元素最先被移除。

Queue queue = new Queue();

添加元素（Enqueue）

使用Enqueue方法将任意类型的元素添加到队列的末尾，由于没有类型安全性，取出时需要进行类型转换。

queue.Enqueue(10); queue.Enqueue("Hello");

移除元素（Dequeue）

使用Dequeue方法移除并返回队列的第一个元素（即最早添加的元素），如果队列为空调用此方法会抛出InvalidOperationException，取出时需要进行类型转换。

int firstElement = (int)queue.Dequeue();

查看队首元素（Peek）

使用Peek方法返回队列的第一个元素但不移除它，取出时需要进行类型转换。

string nextElement = (string)queue.Peek();

遍历Queue

可以使用foreach循环遍历Queue中的所有元素，遍历顺序是从队首到队尾，但遍历过程中每个元素都需要进行类型转换。

foreach (object item in queue) { Console.WriteLine(item); }

常见操作

支持检查队列中元素数量（Count）、清空队列（Clear）、将队列转为数组（ToArray）等操作，但不具备类型安全性。

int count = queue.Count; queue.Clear(); object[] array = queue.ToArray();

适用场景

适用于存储不同类型数据且类型安全性要求不高的场景，但在现代C#开发中通常被泛型队列Queue<T>取代。

Queue mixedQueue = new Queue(); mixedQueue.Enqueue(42); mixedQueue.Enqueue("Task"); int num = (int)mixedQueue.Dequeue();