C#学习第6天：集合（Collections）深入解析

集合提供了一种动态存储多个对象的方法。与数组不同，集合可以根据需要动态调整大小，并提供了多种操作数据的工具。

第一种：List<T> 列表

using System;
using System.Collections.Generic;

public class ListExample
{
    public static void Main(string[] args)
    {
        List<string> fruits = new List<string>() { "Apple", "Banana", "Cherry" };
        
        fruits.Add("Date");
        Console.WriteLine($"Count: {fruits.Count}");  // 输出：4
        
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}

特性

• 动态数组：List<T>是一个大小可变的数组，可以根据需要增加或减少元素。
• 有序集合：保存元素的插入顺序。
• 泛型支持：可以存储任意类型的数据。 

应用场景 

• 通用数据存储：适合任何需要动态、顺序存储数据的场景。
• 快速访问：当需要通过索引快速访问数据时选择List<T>。

高级功能 

• 使用Sort()方法对列表进行排序。
• 使用Reverse()来反转列表顺序。
• 使用Contains()检查是否存在某个元素
• 使用IndexOf()查找元素的位置。

List<int> numbers = new List<int> { 10, 20, 30, 40 };

numbers.Add(50); // 增加元素
numbers.RemoveAt(0); // 移除第一个元素
numbers.Sort();
numbers.Reverse();

bool hasValue = numbers.Contains(30);
int index = numbers.IndexOf(20);

第二种：Dictionary<TKey, TValue>  字典

using System;
using System.Collections.Generic;

public class DictionaryExample
{
    public static void Main(string[] args)
    {
        Dictionary<int, string> studentNames = new Dictionary<int, string>();
        
        studentNames.Add(1, "Alice");
        studentNames[2] = "Bob";
        
        if (studentNames.TryGetValue(1, out string name))
        {
            Console.WriteLine(name);  // 输出：Alice
        }
    }
}

特性

• 键值对：每个元素由一个唯一键和一个关联值组成。
• 无序集合：不保证元素的排列顺序。
• 键的唯一性：键必须是唯一且不可为空（对于引用类型）

应用场景 

• 快速查找：当需要通过唯一标识符快速检索数据时使用Dictionary<TKey, TValue>。
• 映射关系：适合用于存储实体与属性之间的映射关系，如ID到对象的映射。

高级功能 

• Add(key, value)：添加新的键值对。
• Remove(key)：移除指定键的键值对。
• TryGetValue(key, out value)：获取指定键的值并避免异常抛出。

Dictionary<string, int> inventory = new Dictionary<string, int>
{
    { "Apples", 10 },
    { "Bananas", 20 }
};

inventory["Cherries"] = 15; // 添加或更新
int appleCount;
if (inventory.TryGetValue("Apples", out appleCount))
{
    Console.WriteLine($"Apples: {appleCount}");
}
inventory.Remove("Bananas");

第三种：HashSet<T>  哈希集

using System;
using System.Collections.Generic;

public class HashSetExample
{
    public static void Main(string[] args)
    {
        HashSet<string> colors = new HashSet<string>();
        
        colors.Add("Red");
        colors.Add("Blue");
        colors.Add("Red");  // 无法添加重复项
        
        Console.WriteLine($"Count: {colors.Count}");  // 输出：2
    }
}

特性

• 无序存储：HashSet<T>不保证元素的顺序。
• 唯一性：HashSet<T>不允许包含重复的元素。

应用场景 

• 需要快速查找和保证元素唯一性的情况。 

高级功能 

• UnionWith：联合其他集合。
• IntersectWith：取交集。
• ExceptWith：排除其他集合中的元素。

var setA = new HashSet<int> { 1, 2, 3 };
var setB = new HashSet<int> { 3, 4, 5 };

setA.UnionWith(setB); // setA = { 1, 2, 3, 4, 5 }
setA.IntersectWith(setB); // setA = { 3 }
setA.ExceptWith(setB); // setA = { 1, 2 }, assuming original setA was reset

foreach (var item in setA)
{
    Console.WriteLine(item);
}

第四种：Queue<T> 队列

using System;
using System.Collections.Generic;

public class QueueExample
{
    public static void Main(string[] args)
    {
        Queue<string> tasks = new Queue<string>();
        
        tasks.Enqueue("Task1");
        tasks.Enqueue("Task2");
        
        while (tasks.Count > 0)
        {
            Console.WriteLine(tasks.Dequeue());
        }
    }
}

特性

• FIFO（先进先出）：最早进入队列的元素最先被处理。

应用场景 

• 任务调度：按照顺序执行一系列任务。
• 数据流处理：如消息队列，实现生产者-消费者模型。

注意事项 

 线程安全：Queue<T>本身不是线程安全的。对于多线程环境，可以使用ConcurrentQueue<T>。

高级功能 

• Enqueue：将元素添加到队列末尾。
• Dequeue：移除并返回位于队列开头的元素。
• Peek：返回位于队列开头的元素但不移除。

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

queue.Enqueue("Task1");
queue.Enqueue("Task2");

Console.WriteLine(queue.Peek()); // 输出：Task1
Console.WriteLine(queue.Dequeue()); // 输出：Task1
Console.WriteLine(queue.Dequeue()); // 输出：Task2

第五种：Stack<T>  堆栈

using System;
using System.Collections.Generic;

public class StackExample
{
    public static void Main(string[] args)
    {
        Stack<string> history = new Stack<string>();
        
        history.Push("Page1");
        history.Push("Page2");
        
        while (history.Count > 0)
        {
            Console.WriteLine(history.Pop());
        }
    }
}

特性

• LIFO（后进先出）：最近加入堆栈的元素最先处理。

应用场景 

• 撤销功能：保存用户操作历史以便回退。
• 表达式求值：如计算机科学中的逆波兰表达式求值。

高级功能 

• Push：将元素添加到堆栈顶部。
• Pop：移除并返回位于堆栈顶部的元素。
• Peek：返回位于堆栈顶部的元素但不移除。

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

stack.Push("Page1");
stack.Push("Page2");

Console.WriteLine(stack.Peek()); // 输出：Page2
Console.WriteLine(stack.Pop()); // 输出：Page2
Console.WriteLine(stack.Pop()); // 输出：Page1

注意事项 

 线程安全：Stack<T>在多线程环境中使用时需同步或使用ConcurrentStack<T>。

实践习题

Queue和Stack结合：模拟一个简单的任务系统，其中任务以字符串形式存储。在任务完成后，从队列中移除。但是，在每次处理之前，将当前任务存入一个执行历史栈中。

using System;
using System.Collections.Generic;

public class TaskSystem
{
    public static void Main(string[] args)
    {
        Queue<string> taskQueue = new Queue<string>();
        Stack<string> taskHistory = new Stack<string>();

        // 添加任务到队列
        taskQueue.Enqueue("Task1");
        taskQueue.Enqueue("Task2");
        taskQueue.Enqueue("Task3");

        // 执行任务并保存历史
        while (taskQueue.Count > 0)
        {
            string currentTask = taskQueue.Peek(); // 查看但不移除
            taskHistory.Push(currentTask);         // 放入历史栈
            Console.WriteLine($"Processing {currentTask}");
            taskQueue.Dequeue();                   // 完成后从队列移除
        }

        Console.WriteLine("\nTask History:");
        while (taskHistory.Count > 0)
        {
            Console.WriteLine(taskHistory.Pop());
        }
    }
}