c#集合详解-Dictionary、List、Queue、Stack等

using System;

using System.Collections;

class Program
{

    static void Main()
    {

        // 创建一个空的 ArrayList
        ArrayList list1 = new ArrayList();

        

        // 使用初始容量创建 ArrayList
        ArrayList list2 = new ArrayList(10);  // 初始容量为 10

        

        // 从数组创建 ArrayList
        int[] numbers = { 1, 2, 3, 4, 5 };

        ArrayList list3 = new ArrayList(numbers);



        // 使用集合初始化
        ArrayList list4 = new ArrayList { 10, "Hello", 3.14, true };



        // 输出初始化的 ArrayList
        Console.WriteLine("list4:");

        foreach (var item in list4)
        {

            Console.WriteLine(item);

        }

    }

}

输出

list4:

10

Hello

3.14

True

（2）常用方法

①Add(value)

向ArrayList中添加一个元素

例：

ArrayList list = new ArrayList();

list.Add(10);

list.Add("Hello");

Console.WriteLine(list[0]); // 输出：10

Console.WriteLine(list[1]); // 输出：Hello

②AddRange(value)

向ArrayList中添加一个集合中的所有元素

例：

ArrayList list1 = new ArrayList() { 1, 2, 3 };

ArrayList list2 = new ArrayList() { 4, 5, 6 };

list1.AddRange(list2);

Console.WriteLine(string.Join(", ", list1)); // 输出：1, 2, 3, 4, 5, 6

③Insert(index,value)

在指定的位置插入元素

例：

ArrayList list = new ArrayList() { 1, 2, 4 };

list.Insert(2, 3); // 在索引 2 位置插入元素 3

Console.WriteLine(string.Join(", ", list)); // 输出：1, 2, 3, 4

④Remove(value)

从ArrayList中删除第一次出现的指定的元素

例：

ArrayList list = new ArrayList() { 1, 2, 3, 4, 5 };

list.Remove(3); // 删除元素 3

Console.WriteLine(string.Join(", ", list)); // 输出：1, 2, 4, 5

⑤RemoveAt(index)

删除指定索引位置的元素

例：

ArrayList list = new ArrayList() { 1, 2, 3, 4 };

list.RemoveAt(1); // 删除索引 1 处的元素

Console.WriteLine(string.Join(", ", list)); // 输出：1, 3, 4

⑥clear()

删除ArrayList中的所有元素

例：

ArrayList list = new ArrayList() { 1, 2, 3, 4 };

list.Clear();

Console.WriteLine(list.Count); // 输出：0

⑦Contains(value)

判断ArrayList中是否包含指定的元素

例：

ArrayList list = new ArrayList() { 1, 2, 3, 4 };

Console.WriteLine(list.Contains(3)); // 输出：True

Console.WriteLine(list.Contains(5)); // 输出：False

⑧IndexOf(value)

返回指定元素在ArrayList中第一次出现的位置，如果元素不存在则返回-1

例：

ArrayList list = new ArrayList() { 1, 2, 3, 4 };

Console.WriteLine(list.IndexOf(3)); // 输出：2

Console.WriteLine(list.IndexOf(5)); // 输出：-1

⑨Sort()

对ArrayList中的元素进行排序（默认升序）

例：

ArrayList list = new ArrayList() { 4, 2, 1, 3 };

list.Sort();

Console.WriteLine(string.Join(", ", list)); // 输出：1, 2, 3, 4

⑩Reverse()

将ArrayList中元素顺序反转

例：

ArrayList list = new ArrayList() { 1, 2, 3, 4 };

list.Reverse();

Console.WriteLine(string.Join(", ", list)); // 输出：4, 3, 2, 1

（3）总结

优点：动态大小，可以自动扩展，可以存储任意类型的数据

缺点：ArrayList性能较低，因为它是非泛型集合，在增删操作时都需要进行装箱和拆箱操作，所以目前一般推荐使用List<T>来替代ArrayList

2，Hashtable

Hashtable位于System.Collections命名空间下，它存储的是键值对（key-value）形式的数据，类似于字典，每个键（key）在Hashtable中必须是唯一的，而值（value）可以重复

Hashtable可以通过键来快速的查找对应的值，它实现了哈希表数据结构，提供了高效的查找，插入和删除操作

（1）创建Hashtable

例：

using System;

using System.Collections;

class Program
{

    static void Main()
    {

        // 创建一个空的 Hashtable
        Hashtable hashtable = new Hashtable();



        // 使用 Add 方法添加键值对
        hashtable.Add("name", "John");

        hashtable.Add("age", 30);

        hashtable.Add("country", "USA");



        // 通过索引器直接添加
        hashtable["city"] = "New York";



        // 输出内容
        Console.WriteLine("Name: " + hashtable["name"]);

        Console.WriteLine("Age: " + hashtable["age"]);

        Console.WriteLine("Country: " + hashtable["country"]);

        Console.WriteLine("City: " + hashtable["city"]);

    }

}

输出

Name: John

Age: 30

Country: USA

City: New York

（2）常用方法

①Add()

添加键值对，如果键已存在，则会抛出异常

例：

Hashtable hashtable = new Hashtable();

hashtable.Add("name", "Alice");

hashtable.Add("age", 25);

②ContainsKey(value)

判断Hashtable中是否包含指定的键

例：

bool contains = hashtable.ContainsKey("name");

Console.WriteLine(contains); // 输出：True

③containsValue(value)

判断Hashtable中是否包含指定的值

例：

bool containsValue = hashtable.ContainsValue(25);

Console.WriteLine(containsValue); // 输出：True

④Remove(Key)

根据键删除指定的键值对，如果键不存在，则什么也不做

例：

hashtable.Remove("age");

Console.WriteLine(hashtable.ContainsKey("age")); // 输出：False

⑤clear()

清空所有键值对

例：

hashtable.Clear();

Console.WriteLine(hashtable.Count); // 输出：0

⑥keys属性

获取Hashtable中所有的键

例：

foreach (var key in hashtable.Keys)

{

Console.WriteLine(key); // 输出所有键

}

⑦values属性

获取所有的值

例：

foreach (var value in hashtable.Values)

{

Console.WriteLine(value); // 输出所有值

}

⑧索引器

使用索引器来访问指定键的值

例：

Console.WriteLine(hashtable["name"]); // 输出："Alice"

（3）总结

与ArrayList类似，性能较低，推荐使用泛型的Dictionary<Key,Value>来代替

二，泛型集合

泛型集合在定义集合时可以指定元素的类型，而不需要在代码中提前确定具体的类型

1，List<T>

List<T>位于System.Collections.Generic命名空间下，它表示一个动态数组，与 ArrayList类似，推荐使用List<T>

（1）创建List<T>的两种方式

①创建一个空的List

using System;

using System.Collections.Generic;

class Program

{

    static void Main()
    {

        List<int> numbers = new List<int>();  // 创建一个空的 List<int>



        // 向 List 中添加元素
        numbers.Add(10);

        numbers.Add(20);

        numbers.Add(30);



        // 输出所有元素
        foreach (var number in numbers)

        {

            Console.WriteLine(number);

        }

    }

}

②使用初始化器创建List<T>

例：

using System;

using System.Collections.Generic;

class Program

{

    static void Main()
    {

        List<int> numbers = new List<int> { 10, 20, 30 };  // 创建并初始化 List<int>



        // 输出所有元素
        foreach (var number in numbers)
        {

            Console.WriteLine(number);

        }

    }

}

（2）List常用方法

①Add(value)

向List中添加元素

例：

List<int> numbers = new List<int>();

numbers.Add(10); // 向列表中添加数字 10

②Insert(index,value)

在指定索引处插入元素，其他元素后移

例：

numbers.Insert(1, 15); // 在索引 1 处插入数字 15

③Remove(value)

移除List<T>中第一次出现的指定元素

例：

numbers.Remove(15); // 移除值为 15 的元素

④RemoveAt(index)

移除指定索引位置的元素

例：

numbers.RemoveAt(0); // 移除索引 0 处的元素

⑤clear()

移除List中的所有元素

例：

numbers.Clear(); // 清空列表

⑥contains(value)

检查List是否包含指定的元素

例：

bool contains = numbers.Contains(10); // 检查是否包含值 10

Console.WriteLine(contains); // 输出：True

⑦IndexOf(value)

返回指定元素的位置，如果不存在，返回-1

例：

int index = numbers.IndexOf(20); // 返回值 20 的索引

Console.WriteLine(index); // 输出：1

⑧Count

获取List中元素的数量

例：

int count = numbers.Count; // 获取列表的元素数量

Console.WriteLine(count); // 输出：2

⑨Sort()

对List中的元素排序

例：

numbers.Sort(); // 对数字列表进行排序

⑩Reverse()

对List中的元素进行反转

例：

numbers.Reverse(); // 反转列表中的元素

2，Dictionary<Key,Value>

Dictionary位于System.Collection.Generic命名空间下，与上面讲的Hashtable类似，也是一个基于键值对的集合，可以提供快速的查找，插入和删除操作（时间复杂度为O(1)），相比上面的Hashtable，推荐使用Dictionary。不过由于使用哈希表实现，字典的元素存储时是无序的，如果需要有序的字典，可以使用SortedDictionary<Key,Value>

（1）创建Dictionary的两种方式

①创建一个空的Dictionary

using System;

using System.Collections.Generic;

class Program

{

    static void Main()
    {

        Dictionary<int, string> dict = new Dictionary<int, string>();  // 创建一个空字典



        // 向字典中添加元素
        dict.Add(1, "Apple");

        dict.Add(2, "Banana");

        dict.Add(3, "Cherry");



        // 输出所有键值对
        foreach (var kvp in dict)
        {

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

        }

    }

}

②使用初始化器创建并初始化Dictionary

using System;

using System.Collections.Generic;

class Program
{

    static void Main()
    {

        Dictionary<int, string> dict = new Dictionary<int, string>
        {

            { 1, "Apple" },

            { 2, "Banana" },

            { 3, "Cherry" }

        };



        // 输出所有键值对
        foreach (var kvp in dict)
        {

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

        }

    }

}

（2）常用方法和属性

①Add(key,value)

向字典中添加一个新的键值对，如果键已经存在，则会抛出异常

例：

dict.Add(4, "Date"); // 向字典中添加新的键值对

②containskey(key)

判断字典中是否包含指定的键

例：

bool contains = dict.ContainsKey(2); // 检查字典中是否包含键为 2 的项

Console.WriteLine(contains); // 输出：True

③containsValue(value)

检查字典是否包含指定的值

例：

bool contains = dict.ContainsValue("Banana"); // 检查字典中是否包含值 "Banana"

Console.WriteLine(contains); // 输出：True

④Remove(key)

根据给出的键移除字典中的键值对，如果键不存在，则返回false

例：

bool removed = dict.Remove(3); // 移除键为 3 的项

Console.WriteLine(removed); // 输出：True

⑤clear()

移除字典中的所有键值对

例：

dict.Clear(); // 清空字典

⑥Count

获取字典中键值对的数量

例：

int count = dict.Count; // 获取字典中的元素个数

Console.WriteLine(count); // 输出：2

⑦索引器

根据键来访问字典中对应的值，如果不存在，抛出异常

例：

string value = dict[1]; // 获取键为 1 的值

Console.WriteLine(value); // 输出：Apple

（3）遍历字典

可以通过foreach循环遍历字典，前面使用的遍历不做说明

foreach (var kvp in dict)

{

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

}

3，Queue<T>

也就是队列，原则是先进先出，位于System.Collections.Generic命名空间下，它的特点是先进先出

（1）创建队列

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

（2）常用方法和属性

①Enqueue(value)：向队列的末尾添加一个元素

②Dequeue()：从队列的开头移除并返回此元素，如果队列为空，报错

③Peek()：返回队列的第一个元素，但不移除它，如果队列为空，报错

④Count：获取队列中当前元素的数量

⑤clear()：移除队列的所有元素

⑥Contains(value)：检查队列中是否包含指定的元素

⑦ToArray()：将队列的元素复制到一个新的数组中

（3）遍历队列

在遍历时用foreach

例：

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

queue.Enqueue(1);

queue.Enqueue(2);

queue.Enqueue(3);

foreach (var item in queue)

{

Console.WriteLine(item); // 输出：1, 2, 3

}

4，Stack<T>

也就是栈，原理是后进后出，位于System.Collections.Generic命名空间下，常用于函数调用栈，表达式求值等场景

（1）创建栈

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

（2）常用方法和属性

①Push(value)：将元素压入栈顶

②Pop()：移除并返回栈顶的元素，如果栈顶为空，报错

③Peek()：返回栈顶元素，但不移除它，如果栈为空，报错

④Count：获取栈中当前元素的数量

⑤clear()：移除栈中所有元素

⑥Contains(value)：检查栈中是否包含指定的元素

⑦ToArray()：将栈的元素复制到一个新数组中

（3）遍历栈

通过foreach遍历栈

例：

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

stack.Push(1);

stack.Push(2);

stack.Push(3);

foreach (var item in stack)

{

Console.WriteLine(item); // 输出：3, 2, 1

}

5，HashSet<T>

HashSet是一个基于哈希表的集合类，它存储不重复的元素，位于System.Collections.Generic命名空间下，常用于需要快速查找和去重的元素

HashSet中的元素的是唯一的，不能有重复的元素，如果尝试添加重复元素将会失败，同时HashSet中的元素没有特定的顺序，因此它不会像List一样可以按索引访问元素，不过由于哈希表的实现，HashSet提供了非常快的查找、添加和删除操作（时间复杂度通常为O(1)）

（1）创建HashSet

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

（2）常用方法

①Add(value)：向集合中添加元素，如果元素已经存在，返回false，添加成功，返回true

②Remove(value)：从集合中删除指定的元素，如果元素不存在，返回false，删除成功则返回true

③Contains(value)：检查集合中是否包含指定的元素

④Count：获取集合中的元素的数量

⑤clear()：移除集合中的所有元素

⑥UnionWith(HashSet other)：用另一个集合中元素更新当前集合，形成并集，集合中将包含两个集合中的所有元素，但不重复

例：

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };

HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

set1.UnionWith(set2); // set1 变为 { 1, 2, 3, 4, 5 }

⑦IntersectWith(HashSet other)：用另一个集合中的元素更新当前集合，形成交集

⑧ExceptWith(HashSet other)：从当前集合中删除在另一个集合中存在的元素，形成差集

例：

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };

HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

set1.ExceptWith(set2); // set1 变为 { 1, 2 }

（3）遍历HashSet

HashSet<T>是无序集合，因此遍历时元素的顺序不可预测，可以使用foreach 循环遍历

例：

HashSet<int> set = new HashSet<int> { 1, 2, 3, 4, 5 };

foreach (var item in set)

{

Console.WriteLine(item); // 输出：1, 2, 3, 4, 5（顺序不可预测）

}

6，SortedList<key, value>

SortedList也是基于键值对的集合，在存储键值对时会自动按键排序，位于 System.Collections.Generic命名空间下

（1）SortedList的基本特性

①自动排序：根据键的顺序自动排序，可以是升序或自定义的排序方式（如果提供了比较器）

②键唯一：每个键都是唯一的，不能重复

（2）常用方法和属性

①Add(key,value)：向SortedList中添加键值对

②Remove(key)：根据键删除指定的键值对

③ContainsKey(key)：判断是否包含指定的键

④IndexOfKey(key)：获取指定键的位置，如果键不存在，返回-1

⑤Count()：获取SortedList中的元素数量

⑥clear()：清空所有键值对

（3）遍历SortedList

通过foreach直接循环遍历

例：

SortedList<int, string> sortedList = new SortedList<int, string>

{

{ 3, "Three" },

{ 1, "One" },

{ 2, "Two" }

};

foreach (var kvp in sortedList)

{

Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");

}

输出：

Key: 1, Value: One

Key: 2, Value: Two

Key: 3, Value: Three

三，总结

以上就是所有的集合类型，推荐使用泛型类型的集合