C#集合及其操作

在C#中，集合是一种用于存储和管理多个对象的数据结构。.NET框架提供了丰富的集合类型，以满足不同的编程需求。以下是一些常见集合类型的详细介绍及其操作演示：

1. 列表（List<T>）

• 介绍：List<T> 是一个泛型集合，它可以动态调整大小，方便地添加、删除和访问元素。它在 System.Collections.Generic 命名空间中。
• 操作演示：

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 创建一个整数列表
        List<int> numbers = new List<int>();

        // 添加元素
        numbers.Add(1);
        numbers.Add(2);
        numbers.Add(3);

        // 插入元素
        numbers.Insert(1, 10); // 在索引1处插入10

        // 访问元素
        int firstNumber = numbers[0]; // 获取第一个元素

        // 修改元素
        numbers[2] = 20;

        // 删除元素
        numbers.Remove(20); // 删除值为20的元素
        numbers.RemoveAt(1); // 删除索引1处的元素

        // 遍历列表
        foreach (int number in numbers)
        {
            Console.WriteLine(number);
        }

        // 列表大小
        int count = numbers.Count;
    }
}

2. 数组列表（ArrayList）

• 介绍：ArrayList 是一个非泛型集合，可以存储不同类型的对象，但由于类型安全问题，在现代C#编程中，List<T> 更常用。它在 System.Collections 命名空间中。
• 操作演示：

using System;
using System.Collections;

class Program
{
    static void Main()
    {
        ArrayList arrayList = new ArrayList();

        // 添加元素
        arrayList.Add(1);
        arrayList.Add("Hello");
        arrayList.Add(true);

        // 访问元素
        int firstElement = (int)arrayList[0]; // 需要进行类型转换

        // 删除元素
        arrayList.Remove("Hello");

        // 遍历列表
        foreach (object item in arrayList)
        {
            Console.WriteLine(item);
        }

        // 列表大小
        int count = arrayList.Count;
    }
}

3. 字典（Dictionary<TKey, TValue>）

• 介绍：Dictionary<TKey, TValue> 是一个泛型集合，用于存储键值对。它提供了快速的查找功能，基于键来访问值。它在 System.Collections.Generic 命名空间中。
• 操作演示：

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 创建一个字符串到整数的字典
        Dictionary<string, int> scores = new Dictionary<string, int>();

        // 添加键值对
        scores.Add("Alice", 85);
        scores.Add("Bob", 90);

        // 访问值
        int aliceScore = scores["Alice"];

        // 修改值
        scores["Bob"] = 95;

        // 检查键是否存在
        bool hasKey = scores.ContainsKey("Charlie");

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

        // 遍历字典
        foreach (KeyValuePair<string, int> pair in scores)
        {
            Console.WriteLine($"{pair.Key}: {pair.Value}");
        }
    }
}

4. 哈希集（HashSet<T>）

• 介绍：HashSet<T> 是一个泛型集合，它存储唯一的元素，不允许重复。它在 System.Collections.Generic 命名空间中。
• 操作演示：

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 创建一个整数哈希集
        HashSet<int> numbers = new HashSet<int>();

        // 添加元素
        numbers.Add(1);
        numbers.Add(2);
        numbers.Add(2); // 重复添加，不会增加新元素

        // 检查元素是否存在
        bool contains = numbers.Contains(1);

        // 删除元素
        numbers.Remove(2);

        // 遍历哈希集
        foreach (int number in numbers)
        {
            Console.WriteLine(number);
        }
    }
}

5. 队列（Queue<T>）

• 介绍：Queue<T> 是一个泛型集合，它遵循先进先出（FIFO）的原则。新元素添加到队列的末尾，元素从队列的开头移除。它在 System.Collections.Generic 命名空间中。
• 操作演示：

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 创建一个整数队列
        Queue<int> queue = new Queue<int>();

        // 入队
        queue.Enqueue(1);
        queue.Enqueue(2);
        queue.Enqueue(3);

        // 出队
        int first = queue.Dequeue(); // 返回1

        // 查看队首元素但不移除
        int peek = queue.Peek(); // 返回2

        // 队列大小
        int count = queue.Count;
    }
}

6. 栈（Stack<T>）

• 介绍：Stack<T> 是一个泛型集合，它遵循后进先出（LIFO）的原则。新元素添加到栈的顶部，元素从栈的顶部移除。它在 System.Collections.Generic 命名空间中。
• 操作演示：

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 创建一个整数栈
        Stack<int> stack = new Stack<int>();

        // 入栈
        stack.Push(1);
        stack.Push(2);
        stack.Push(3);

        // 出栈
        int top = stack.Pop(); // 返回3

        // 查看栈顶元素但不移除
        int peek = stack.Peek(); // 返回2

        // 栈大小
        int count = stack.Count;
    }
}

这些集合类型在C#编程中非常常用，根据具体的需求选择合适的集合类型可以提高程序的效率和可读性。