C#中的常用集合

目录

一、动态数组ArrayList

二、List

三、栈（Stack）

四、队列（Queue）

五、字典（Dictionary）,int>

一、动态数组ArrayList

ArrayList 是 C# 中提供的一种动态数组类，位于命名空间 System.Collections 中。

动态数组（ArrayList）与普通数组不同，它的大小可以动态调整，无需预先定义固定长度。

动态数组（ArrayList）代表了可被单独索引的对象的有序集合，它也允许在列表中进行动态内存分配、增加、搜索、排序各项。

ArrayList 类适用于需要频繁调整大小的数组操作，但由于其非泛型特性，在现代 C# 开发中逐渐被 List<T> 替代。

具体来说ArrayList和List的区别在于ArrayList是一个非泛型集合，List是一个泛型集合，就是说ArrayList中可以存储任意类型的元素，而List只能包含制定类型的元素。

性能方面List更好

现在在C#中一般常用的都是List了，很少用到ArrayList

ArrayList 类的方法和属性

下表列出了 ArrayList 类的一些常用的 属性：

下表列出了 ArrayList 类的一些常用的 方法：

 static void Main(string[] args)
        {
            ArrayList a = new ArrayList();
            a.Add("ioio");
            a.Add(12);
            a.Add(58.2f);
            for(int i = 0; i < a.Count; i++)
            {
                Console.WriteLine(a[i]);
            }
        }

二、List

static void Main(string[] args)
        {
            List<int> a = new List<int>();
            //添加元素
            a.Add(12);
            a.Add(13);
            a.Add(15);
            a.Add(18);
            a.Add(2);
            shuchu(a);
            //删除元素13
            a.Remove(13);
            shuchu(a);
            //删除索引1
            a.RemoveAt(1);
            shuchu(a);
            //获得指定对象首次出现的索引
            Console.WriteLine(a.IndexOf(12));
            //获得指定对象最后一处出现的索引位置
            Console.WriteLine(a.LastIndexOf(12));
            
        }
       static void shuchu(List<int> a)
        {
            //遍历List
            foreach(int i in a)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
        }

三、栈（Stack）

 static void Main(string[] args)
        {
            Stack<int> a = new Stack<int>();
            //进栈
            a.Push(1);
            a.Push(2);
            a.Push(3);
            a.Push(4);
            a.Push(5);
            //输出
            shuchu(a);

            //出栈
            a.Pop();
            //输出
            shuchu(a);
            //返回栈顶元素
            Console.WriteLine(a.Peek());
            
        }
       static void shuchu(Stack<int> a)
        {
            //遍历List
            foreach(int i in a)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
        }

四、队列（Queue）

在 C# 中，Queue 是一个先进先出（FIFO, First In First Out）数据结构。

Queue 属于 System.Collections 或 System.Collections.Generic 命名空间，分别提供非泛型和泛型版本的实现。Queue 适用于需要按照入队顺序处理数据的场景。

队列（Queue）代表了一个先进先出的对象集合。当您需要对各项进行先进先出的访问时，则使用队列。当您在列表中添加一项，称为入队，当您从列表中移除一项时，称为出队。

特性

• 先进先出：最早加入队列的元素最先被移除。
• 动态大小：队列的容量会根据需要动态调整。
• 泛型支持：通过 Queue<T> 可以存储强类型的元素。
• 线程安全：Queue 本身不是线程安全的，但可以使用 ConcurrentQueue<T> 实现线程安全。

 static void Main(string[] args)
        {
            Queue<int> a = new Queue<int>();
            //添加元素进入队列中
            a.Enqueue(1);
            a.Enqueue(2);
            a.Enqueue(3);
            a.Enqueue(4);
            a.Enqueue(5);
            //输出
            shuchu(a);
            //删除先进的
            a.Dequeue();
            //输出
            shuchu(a);
            //返回队列开头的元素
            Console.WriteLine("队列开头元素=" + a.Peek());
            //确定某个元素是否在队列中
            Console.WriteLine(a.Contains(13));
            //清空队列中的元素
            a.Clear();
        }
       static void shuchu(Queue<int> a)
        {
            //遍历List
            foreach(int i in a)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
        }

五、字典（Dictionary<string,int>）

static void Main(string[] args)
        {
            Dictionary<string, int> a = new Dictionary<string, int>();
            //向字典中添加元素
            a.Add("第一个键", 11);
            a.Add("第二个键", 2);
            a.Add("第三个键", 3);
            a.Add("第四个键", 4);
            a.Add("第五个键", 5);
            shuchu(a);

            //确定字典中是否含有指定的键
            Console.WriteLine(a.ContainsKey("第一个键"));

            //确定字典中是否含有指定的值
            Console.WriteLine(a.ContainsValue(100));

            //将带有指定键的键值对给删除，根据键删除
            a.Remove("第一个键");
            shuchu(a);

            //返回一个键的集合
            var key = a.Keys;//同样的还可以返回一个值的集合，方法是Values
            foreach(var i in key)
            {
                Console.WriteLine(i);
            }
        }
       static void shuchu(Dictionary<string,int> a)
        {
            //遍历字典中的数据
            foreach(var d in a)
            {
                Console.WriteLine("键="+d.Key + " 值=" + d.Value);
            }
            return;
        }