C# 集合

ArrayList

ArrayList是一个动态的数组。其可存储的元素类型为object，也就是说它可以存储任何类型的对象。所有元素都被视为 object 类型。因而值类型被存储到ArrayList中会被装箱成为引用类型。实际上，ArrayList内部也就是使用一个object[]来存放元素。

与数组相比，ArrayList的优点在于可以动态调节大小，存储的元素类型可以不一致。

但缺点就在于对于存取值类型来说，需要进行装箱和拆箱操作，带来性能上的开销。

除了元素数量外，ArrayList还有一个容量 (capacity) 的概念，这个容量是ArrayList内object[]的实际长度，而Count是object[]中元素的数量。

当对ArrayList进行添加操作时，添加的元素数量一旦超过容量，容量会翻倍并创建一个新的object[]，将原object[]通过Array.Copy()拷贝到新数组中，最后将需要添加的元素也拷贝进这个新object[]中。

创建 ArrayList 实例

// 创建一个 Count = 0, Capacity = 0 的 ArrayList 实例
ArrayList arr1 = new ArrayList(); 

// 创建一个 Count = 0, Capacity = 0 的 ArrayList 实例
ArrayList arr2 = new ArrayList(10); 

// 创建一个 Count = 3, Capacity = 3 的 ArrayList 实例
ArrayList arr3 = new ArrayList(new int[] {1,2,3});

属性

ArrayList arr = new ArrayList(new int[] { 1, 2, 3 });

// 获取元素数量
Console.WriteLine($"arr中含有的元素数量为：{arr.Count}"); // arr中含有的元素数量为：3

// 获取容量
Console.WriteLine($"arr的容量为：{arr.Capacity}");   // arr的容量为：3

// 获取指定下标元素
Console.WriteLine($"arr[0]：{arr[0]}");  // arr[0]：1

// 获取表示该ArrayList实例是否具有固定大小的布尔值
Console.WriteLine($"arr的大小{(arr.IsFixedSize ? "固定" : "不固定")}"); // arr的大小不固定

// 获取表示该ArrayList实例是否为只读的布尔值
Console.WriteLine($"arr{(arr.IsFixedSize ? "是" : "不是")}只读的");   // arr不是只读的

// 获取表示该ArrayList实例是否为同步的布尔值
Console.WriteLine($"arr{(arr.IsSynchronized ? "是" : "不是")}同步的");    // arr不是同步的

方法

ArrayList arr = new ArrayList(new int[]{1,2,3});

// 将元素转移到数组中
Console.WriteLine($"arr转移到数组中: {string.Join(", ", arr.ToArray())}\n");
// arr转移到数组中: 1, 2, 3
    
// 添加
arr.Add("Hello!");  // 添加一个字符串
arr.Add(new string[] {"rzzy","RZZY" }); // 将字符串数组作为一个元素添加进去
arr.AddRange(new string[] {"rzzy","RZZY" }); // 将字符串数组中每个字符串添加进去
Console.WriteLine($"arr: {string.Join(", ",arr.ToArray())}\n"); 
// arr添加后: 1, 2, 3, Hello!, System.String[], rzzy, RZZY

// 插入
arr.Insert(2,"插入1");
arr.InsertRange(5, new string[]{"插入2", "插入3"});
Console.WriteLine($"arr: {string.Join(", ",arr.ToArray())}\n");
// arr插入后: 1, 2, 插入1, 3, Hello!, 插入2, 插入3, System.String[], rzzy, RZZY

// 删除
// arr.Clear(); 清除所有元素，容量不变。这里不使用，以免影响后续运行。
arr.Remove("插入1");
arr.RemoveAt(5);
arr.RemoveRange(0,3);
Console.WriteLine($"arr删除后: {string.Join(", ",arr.ToArray())}\n");
// arr删除后: Hello!, 插入2, System.String[], rzzy, RZZY

// 查找
// arr.BinarySearch(object value); 该重载由于使用默认比较器，而我们的ArrayList中类型不同，异常率极高，遂放弃使用
bool contains = arr.Contains("RZZY");
int i1 = arr.IndexOf("rzzy");
int i2 = arr.LastIndexOf("日之朝矣");
Console.WriteLine($@"arr {(contains ? "包含" : "不包含")} ""RZZY"", ""rzzy"" 在 arr 里的索引为{i1}, ""日之朝矣"" 在 arr 中的索引为{i2}\n");
// arr 包含 "RZZY", "rzzy" 在 arr 里的索引为3, "日之朝矣" 在 arr 中的索引为-1

Console.WriteLine();

// 倒序
arr.Reverse();
Console.WriteLine($"arr全体倒序后: {string.Join(", ",arr.ToArray())}");
// arr全体倒序后: RZZY, rzzy, System.String[], 插入2, Hello!

// 从第 0 个元素开始 3 个元素倒序
arr.Reverse(0,3);
Console.WriteLine($"arr[0,3]倒序后: {string.Join(", ",arr.ToArray())}\n");
// arr[0,3]倒序后: System.String[], rzzy, RZZY, 插入2, Hello!

// 排序
// arr.Sort(); 如果存储元素类型不同，则默认比较器不可靠，需要根据实际情况去实现IComparer接口
arr.RemoveAt(0); // 移除后当前元素仅剩字符串
arr.Sort();
Console.WriteLine($"arr使用默认比较器排序后: {string.Join(", ",arr.ToArray())}\n");
// arr使用默认比较器排序后: Hello!, rzzy, RZZY, 插入2

arr.Sort(new MyComparer()); // 实现 IComparer 的类在下一个代码块中
Console.WriteLine($"arr使用自定义比较器反向排序后: {string.Join(", ",arr.ToArray())}\n");
// arr使用自定义比较器反向排序后: 插入2, rzzy, RZZY, Hello!


ArrayList stuList = new ArrayList(new Student[]{ new Student("001","张三"), new Student("002","李四"),new Student("001","王五")});
// C# ArrayList 中所有关于元素复制的方法都是浅复制

// arr.Clone(); 创建 ArrayList 的浅表副本。
ArrayList stuList2 = (ArrayList)stuList.Clone();
// arr.CopyTo(); 将 ArrayList 或它的一部分复制到一维数组。
Student[] stuArr = new Student[stuList.Count]; 
stuList.CopyTo(stuArr);
// arr.GetRange(); 返回一个 ArrayList，它表示源 ArrayList 中的元素子集。
ArrayList stuList3 = stuList.GetRange(0, stuArr.Length);

((Student)stuList[0]).Name = "二蛋";
Console.WriteLine($"stuList2[0].Name: {((Student)stuList2[0]).Name}"); // stuList2[0].Name: 二蛋
Console.WriteLine($"stuArr[0].Name: {stuArr[0].Name}"); // stuArr[0].Name: 二蛋
Console.WriteLine($"stuList3[0].Name: {((Student)stuList3[0]).Name}"); // stuList3[0].Name: 二蛋

// ArrayList.Repeat()
ArrayList stuList4 = ArrayList.Repeat("你好", 5);
Console.WriteLine($"stuList4: {string.Join(",",stuList4.ToArray())}"); // stuList4: 你好,你好,你好,你好,你好

// arr.SetRange() 设置 arr 中的值
stuList.SetRange(0, new string[]{"你好1","你好2"});
Console.WriteLine($"stuList使用SetRange后: {string.Join(", ", stuList.ToArray())}\n"); // stuList使用SetRange后: 你好1, 你好2, 测试用.Program+Student

stuList.TrimToSize(); // 将容量设置为 ArrayList 中元素的实际数目。
ArrayList stuList5 =  ArrayList.FixedSize(stuList); // 返回具有固定大小的 ArrayList 包装。
ArrayList stuList6 =  ArrayList.ReadOnly(stuList); // 返回返回只读的列表包装。
ArrayList stuList7 =  ArrayList.Synchronized(stuList); // 返回同步的（线程安全）列表包装。

ArrayList stuList8 =  ArrayList.Adapter(stuArr); // 适配器：把实现IList接口的其他对象转换成ArrayList

IEnumerator IstuList = stuList.GetEnumerator(); // 返回循环访问 ArrayList 的枚举数。
IstuList.MoveNext(); // 移动一位开始枚举
Console.WriteLine(IstuList.Current.ToString()); ;// 你好1

// 该例子来自于Microsoft Learn C# API System.IComparer 接口中
class MyComparer : IComparer
{
    public int Compare(object x, object y)
    {
        return (new CaseInsensitiveComparer()).Compare(y,x);
    }
}

class Student
{
    public string Id { get; set; }
    public string Name { get; set; }

    public Student(string id, string name)
    {
        Id = id;
        Name = name;
    }
}

使用 Array.FindAll() 寻找元素

Object[] o = Array.FindAll(stuList.ToArray(), item =>
                           {
                               if(item is Student)
                               { 
                                   if (((Student)item).Name == "王五")
                                       return true;
                               }
                               return false;
                           });
Console.WriteLine(o.Length); // 1

List

List<T> 是 C# 中常用的泛型集合类型，提供了动态数组的功能。它位于 System.Collections.Generic 命名空间中，能够自动调整大小，提供高效的元素访问和操作。

与ArrayList相比，List<T>只能同时存放一种类型，避免了装箱和拆箱的开销，而且在获取元素时不需要进行类型转换。因此，除非必须处理不同类型的对象，一般使用 List<T>。

创建List实例

// 创建一个 Count = 0, Capacity = 0 的 List<int> 实例
List<int> list = new List<int>();
// 创建一个 Count = 0, Capacity = 5 的 List<int> 实例
List<int> list2 = new List<int>(5);
// 创建一个 Count = 2, Capacity = 2 的 List<string> 实例
List<string> list3  = new List<string>(new string[]{ "rzzy","RZZY"});

属性

List<T>可以使用的使用的属性与ArrayList一致。

Capacity	获取或设置该内部数据结构在不调整大小的情况下能够容纳的元素总数。
Count	获取 List 中包含的元素数。
Item[Int32]	获取或设置指定索引处的元素。

方法

List<T>可以使用的方法几乎与ArrayList一致。

这里仅列出常用的方法

此表从 MicroSoft Learn C# API List 复制而来，有删减。

方法名	描述
Add(T)	将对象添加到 List 的结尾处。
AddRange(IEnumerable)	将指定集合的元素添加到 List 的末尾。
AsReadOnly()	返回当前集合的只读 ReadOnlyCollection 包装器。
Clear()	从 List 中移除所有元素。
Contains(T)	确定某元素是否在 List中。
ConvertAll(Converter)	将当前 List中的元素转换为另一种类型，并返回包含已转换元素的列表。
CopyTo(Int32, T], Int32, Int32)	从目标数组的指定索引处开始，将元素的范围从 List 复制到兼容的一维数组。
CopyTo(T])	从目标数组的开头开始，将整个 List 复制到兼容的一维数组。
CopyTo(T], Int32)	从目标数组的指定索引处开始，将整个 List 复制到兼容的一维数组。
Exists(Predicate)	确定 List 是否包含与指定谓词定义的条件匹配的元素。
Find(Predicate)	搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的第一个匹配元素。
FindAll(Predicate)	检索与指定谓词定义的条件匹配的所有元素。
FindIndex(Int32, Int32, Predicate)	搜索与指定谓词所定义的条件相匹配的一个元素，并返回 List 中从指定的索引开始、包含指定元素个数的元素范围内第一个匹配项的从零开始的索引。
FindIndex(Int32, Predicate)	搜索与指定谓词所定义的条件相匹配的元素，并返回 List 中从指定索引到最后一个元素的元素范围内第一个匹配项的从零开始的索引。
FindIndex(Predicate)	搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中第一个匹配元素的从零开始的索引。
FindLast(Predicate)	搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的最后一个匹配元素。
FindLastIndex(Int32, Int32, Predicate)	搜索与指定谓词所定义的条件相匹配的元素，并返回 List 中包含指定元素个数、到指定索引结束的元素范围内最后一个匹配项的从零开始的索引。
FindLastIndex(Int32, Predicate)	搜索与由指定谓词定义的条件相匹配的元素，并返回 List 中从第一个元素到指定索引的元素范围内最后一个匹配项的从零开始的索引。
FindLastIndex(Predicate)	搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中最后一个匹配元素的从零开始的索引。
ForEach(Action)	对 List 的每个元素执行指定操作。
GetEnumerator()	返回循环访问 List 的枚举数。
GetRange(Int32, Int32)	在源 List 中创建元素范围的浅表复制。
IndexOf(T)	搜索指定的对象，并返回整个 List 中第一个匹配项的从零开始的索引。
IndexOf(T, Int32)	搜索指定对象并返回 List 中从指定索引到最后一个元素这部分元素中第一个匹配项的从零开始索引。
IndexOf(T, Int32, Int32)	搜索指定对象并返回 List 中从指定索引开始并包含指定元素数的这部分元素中第一个匹配项的从零开始索引。
Insert(Int32, T)	将元素插入 List 的指定索引处。
InsertRange(Int32, IEnumerable)	将集合中的元素插入 List 的指定索引处。
LastIndexOf(T)	搜索指定对象并返回整个 List 中最后一个匹配项的从零开始索引。
LastIndexOf(T, Int32)	搜索指定对象并返回 List 中从第一个元素到指定索引这部分元素中最后一个匹配项的从零开始的索引。
LastIndexOf(T, Int32, Int32)	搜索指定对象并返回 List 中到指定索引为止包含指定元素数的这部分元素中最后一个匹配项的从零开始索引。
Remove(T)	从 List 中移除特定对象的第一个匹配项。
RemoveAll(Predicate)	移除与指定的谓词所定义的条件相匹配的所有元素。
RemoveAt(Int32)	移除 List 的指定索引处的元素。
RemoveRange(Int32, Int32)	从 List 中移除一系列元素。
Reverse()	将整个List 中元素的顺序反转。
Reverse(Int32, Int32)	将指定范围中元素的顺序反转。
Sort()	使用默认比较器对整个 List 中的元素进行排序。
Sort(Comparison)	使用指定的 Comparison ，对整个 List 中的元素进行排序。
Sort(IComparer)	使用指定的比较器对整个 List 中的元素进行排序。
Sort(Int32, Int32, IComparer)	使用指定的比较器对 List 中某个范围内的元素进行排序。
ToArray()	将 List 的元素复制到新数组中。
TrimExcess()	将容量设置为 List 中元素的实际数目（如果该数目小于某个阈值）。
TrueForAll(Predicate)	确定 List 中的每个元素是否都与指定谓词定义的条件匹配。

Dictionary

Dictionary<TKey, TValue> 是 C# 中一个常用的泛型集合，存储键值对（key-value pairs），并根据键快速查找值。

键值对存储：
- Dictionary 使用键值对的形式存储数据，其中每个键是唯一的，并映射到一个特定的值。
快速查找：
- 使用哈希表（hash table）实现，提供 O(1) 时间复杂度的快速查找、插入和删除操作。
键的唯一性：
- 键必须是唯一的。如果尝试添加一个已经存在的键，会抛出 ArgumentException。
泛型类型：
- 键和值可以是任何类型，由泛型参数 TKey 和 TValue 指定。

在使用中，可以利用其键唯一的特性进行去重操作。

创建Dictionary 实例

Dictionary<string,string> dict1 = new Dictionary<string, string>();

// 定义一个容量为 2 的 Dictionary
Dictionary<string, string> dict2 = new Dictionary<string, string>(2);
// 复制一个Dictionary
Dictionary<string, string> dict3 = new Dictionary<string, string>(dict2);

属性

Count：获取包含在 Dictionary<TKey, TValue> 中的键值对的数目。
Keys：获取包含 Dictionary<TKey, TValue> 中的键的 ICollection<TKey>。
Values：获取包含 Dictionary<TKey, TValue> 中的值的 ICollection<TValue>。
this[key]：获取或设置与指定的键相关联的值。

Dictionary<string,int> dict1 = new Dictionary<string, int>()
{
    { "Alice", 30 },
    { "Bob", 25 },
    { "Charlie", 35 }
};

Console.WriteLine($"dict1中有{dict1.Count}个元素"); // dict1中有3个元素
Console.WriteLine($"dict1中的key有：{string.Join(",", dict1.Keys)}"); // dict1中的key有：Alice,Bob,Charlie
Console.WriteLine($"dict1中的value有：{string.Join(",", dict1.Values)}"); // dict1中的value有：30,25,35
Console.WriteLine($@"dict1[""Alice""] 为 {dict1["Alice"]}"); // dict1["Alice"] 为 30

方法

void Add(TKey key, TValue value)：将指定的键和值添加到字典中。
bool ContainsKey(TKey key)：确定 Dictionary<TKey, TValue> 是否包含指定的键。
bool ContainsValue(TValue value)：确定 Dictionary<TKey, TValue> 是否包含指定的值。
bool Remove(TKey key)：从 Dictionary<TKey, TValue> 中移除具有指定键的值。
bool TryGetValue(TKey key, out TValue value)：获取与指定的键相关联的值。如果操作成功，返回 true；否则，返回 false。
void Clear()：从 Dictionary<TKey, TValue> 中移除所有键和值。

一些方法如Clear()也可用于 Dictionary。

示例

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 创建一个 Dictionary<string, int>
        Dictionary<string, int> ages = new Dictionary<string, int>();

        // 添加键值对
        ages.Add("Alice", 30);
        ages.Add("Bob", 25);

        // 访问值
        Console.WriteLine(ages["Alice"]); // 输出: 30

        // 更新值
        ages["Alice"] = 31;

        // 检查键是否存在
        if (ages.ContainsKey("Charlie"))
        {
            Console.WriteLine("Charlie 的年龄是 " + ages["Charlie"]);
        }
        else
        {
            Console.WriteLine("没有找到 Charlie 的年龄");
        }

        // 尝试获取值
        if (ages.TryGetValue("Bob", out int bobAge))
        {
            Console.WriteLine("Bob 的年龄是 " + bobAge);
        }

        // 删除键值对
        ages.Remove("Bob");

        // 遍历字典
        foreach (KeyValuePair<string, int> kvp in ages)
        {
            Console.WriteLine("Name: {0}, Age: {1}", kvp.Key, kvp.Value);
        }
    }
}

Queue

Queue<T> 是 C# 中的一个泛型集合类，用于表示先进先出（First In First Out）的一组对象。

创建Queue实例

// 创建一个 Capacity = 0， Count = 0 的 Queue 实例
Queue<string> queue1 = new Queue<string>();
// 创建一个 Capacity = 3, Count = 0 的 Queue 实例
Queue<string> queue2 = new Queue<string>(3);
// 创建一个 Capacity = 3, Count = 3 的 Queue 实例
Queue<string> queue3 = new Queue<string>(new string[]{ "rzzy","RZZY","日之朝矣"});

属性

Count:获取元素个数

Queue<string> queue3 = new Queue<string>(new string[]{ "rzzy","RZZY","日之朝矣"});

Console.WriteLine($"queue3有{queue3.Count}个元素"); // queue3有3个元素

方法

void Enqueue(T item)：将对象添加到 Queue<T> 的末尾。
T Dequeue()：移除并返回位于 Queue<T> 开始处的对象。如果队列为空，会抛出 InvalidOperationException。
T Peek()：返回位于 Queue<T> 开始处的对象但不将其移除。如果队列为空，会抛出 InvalidOperationException。
bool Contains(T item)：确定某元素是否在 Queue<T> 中。
void Clear()：移除 Queue<T> 中的所有对象。
T[] ToArray()：将 Queue<T> 元素复制到新数组中。
void TrimExcess()：将容量设置为 Count 的实际元素数，如果元素数小于当前容量的 90%。

Queue<string> queue3 = new Queue<string>(new string[]{ "rzzy","RZZY","日之朝矣"});

Console.WriteLine($"queue3: {string.Join(",", queue3.ToArray())}\n"); // queue3: rzzy,RZZY,日之朝矣

queue3.Enqueue("茉莉");
Console.WriteLine($"queue3添加后: {string.Join(",", queue3.ToArray())}\n"); // queue3添加后: rzzy,RZZY,日之朝矣,茉莉

Console.WriteLine($"queue3.Dequeue(): {queue3.Dequeue()}"); // queue3.Dequeue(): rzzy
Console.WriteLine($"queue3.Dequeue()后: {string.Join(",", queue3.ToArray())}\n"); // queue3.Dequeue()后: RZZY,日之朝矣,茉莉

Console.WriteLine($"queue3.Peek(): {queue3.Peek()}\n"); // queue3.Peek(): RZZY

Console.WriteLine($@"queue3.Contains(""茉莉""): {queue3.Contains("茉莉")}"); // queue3.Contains("茉莉"): True

queue3.Clear();
queue3.TrimExcess();
Console.WriteLine($"queue3.Clear()后，queue3.Count: {queue3.Count}\n"); // queue3.Clear()后，queue3.Count: 0

Stack

Stack<T> 是 C# 中的一个泛型集合类，用于表示后进先出（Last In First Out）的一组对象，与队列（Queue）正好相反。

创建Stack实例

// 创建一个 Capacity = 0， Count = 0 的 Stack 实例
Stack<string> stack1 = new Stack<string>();
// 创建一个 Capacity = 3， Count = 0 的 Stack 实例
Stack<string> stack2 = new Stack<string>(3);
// 创建一个 Capacity = 3， Count = 3 的 Stack 实例
Stack<string> stack3 = new Stack<string>(new string[]{ "rzzy","RZZY","日之朝矣"});

属性

Stack<string> stack3 = new Stack<string>(new string[]{ "rzzy","RZZY","日之朝矣"});

Console.WriteLine($"stack3.Count: {stack3.Count}");

方法

void Push(T item)：将对象添加到 Stack<T> 的顶端。
T Pop()：移除并返回位于 Stack<T> 顶端的对象。如果堆栈为空，会抛出 InvalidOperationException。
T Peek()：返回位于 Stack<T> 顶端的对象但不将其移除。如果堆栈为空，会抛出 InvalidOperationException。
bool Contains(T item)：确定某元素是否在 Stack<T> 中。
void Clear()：移除 Stack<T> 中的所有对象。
T[] ToArray()：将 Stack<T> 元素复制到新数组中。
void TrimExcess()：将容量设置为 Count 的实际元素数，如果元素数小于当前容量的 90%。

Stack<string> stack3 = new Stack<string>(new string[]{ "rzzy","RZZY","日之朝矣"});

Console.WriteLine($"stack3: {string.Join(",", stack3.ToArray())}\n"); // stack3: 日之朝矣,RZZY,rzzy

stack3.Push("茉莉");
Console.WriteLine($"stack3.Push()后: {string.Join(",", stack3.ToArray())}\n"); // stack3.Push()后: 茉莉,日之朝矣,RZZY,rzzy

Console.WriteLine($"stack3.Pop(): {stack3.Pop()}");  // stack3.Pop(): 茉莉
Console.WriteLine($"stack3.Pop()后: {string.Join(",", stack3.ToArray())}\n"); // stack3.Pop()后: 日之朝矣,RZZY,rzzy

Console.WriteLine($"stack3.Peek(): {stack3.Peek()}\n"); // stack3.Peek(): 日之朝矣

Console.WriteLine($@"stack3.Contains(""茉莉""): {stack3.Contains("茉莉")}");  // stack3.Contains("茉莉"): False
//
stack3.Clear();
stack3.TrimExcess();
Console.WriteLine($"stack3.Clear()后，stack3.Count: {stack3.Count}\n"); // stack3.Clear()后，stack3.Count: 0

参考内容

参考内容：
Microsoft Learn .NET API
菜鸟教程 - C# 教程
ChatGPT

RZZY's Blog