【C#】常用的集合类型

【C#】常用的集合类型

常用的数据结构包括动态数组(ArrayList)、堆栈(Stack)、队列(Queue)和哈希表(Hashtable),这些集合类型都是C#为我们封装好的类型,需要引入命名空间 System.Collections

1. ArrayList(动态数组)

本质是一个object类型的有序数组,数据存取可能存在装箱拆箱问题,耗费性能。

static void Main(string[] args)
{
    ArrayList array = new ArrayList();
    
    #region
    array.Add(1);//Add:将object类型的对象添加到ArrayList的结尾处
    array.Add("123");
    array.Add(true);
    array.Add(new object());
    array.Add(new Program());

    ArrayList array2 = new ArrayList();
    array.AddRange(array2);//AddRange:将ICollection的元素添加到ArrayList的末尾

    array.Insert(1, "123456789");//Insert:将元素插入ArrayList的指定索引处
    Console.WriteLine(array[1]);//输出:123456789
    #endregion
    
    #region

    array.Remove(1);//Remove:从ArrayList中移除特定对象的第一个匹配项

    array.RemoveAt(2);//RemoveAt:移除ArrayList的指定索引处的元素

    array.Clear();//Clear:从ArrayList中移除所有元素
    #endregion

    array.Add(1);
    array.Add("1234");
    array.Add(true);
    array.Add(true);     
      
    #region

    Console.WriteLine(array[0]);//输出:1  ||指定ArrayList索引位置进行读取,索引位置不存在抛异常

    if(array.Contains("1234"))//Contains:确定某元素是否在ArrayList中
    {
        Console.WriteLine("存在1234");//输出
    }    
    int index = array.IndexOf(true);//IndexOf:搜索指定object并返回整个内的第一个匹配项的从零开始索引ArrayList,找不到返回-1
    Console.WriteLine(index);//输出:2
    Console.WriteLine(array.IndexOf(false));//输出:-1

    index = array.LastIndexOf(true);//LastIndexOf:在整个ArrayList中搜索指定的object,并返回最后一个匹配项的从零开始的索引,否则返回-1
    Console.WriteLine(index);//输出:3
    #endregion

    #region
    Console.WriteLine(array[0]);//输出:1
    array[0] = "999";//指定ArrayList索引位置进行更改,索引位置不存在抛异常
    Console.WriteLine(array[0]);//输出:999
    #endregion

    #region 遍历

    Console.WriteLine(array.Count);//Count:获取ArrayList中实际包含的元素数

    Console.WriteLine(array.Capacity);
//Capacity:ArrayList可包含的元素数,俗称容量
    
    //方式一:通过下标索引进行遍历
    for(int i = 0; i < array.Count; i++)
    {
        Console.WriteLine(array[i]);//每次分别输出:999 1234 True True
    }
    
    //方式二:迭代器遍历
    foreach (object item in array)
    {
        Console.WriteLine(item);//每次分别输出:999 1234 True True
    }
    #endregion
    
    Console.ReadLine();
}

2. Stack(堆栈)

Stack是一种先进后出的数据结构,它的本质也是object[]数组,只是封装了特殊的存储规则

static void Main(string[] args)
{
    Stack stack = new Stack();

    #region
    stack.Push(1);//Push:在Stack的顶部插入一个对象
    stack.Push("123");
    stack.Push(true);
    stack.Push(1.2f);
    stack.Push(new object());
    #endregion

    #region
    object v = stack.Pop();//Pop:删除并返回Stack顶部的对象,Stack无元素时抛异常
    Console.WriteLine(v);//输出:System.Object

    v = stack.Pop();
    Console.WriteLine(v);//输出:1.2
    #endregion

    #region
    v = stack.Peek();//Peek:返回的对象顶部的Stack而不删除它,Stack无元素时抛异常
    Console.WriteLine(v);//输出:true
    v = stack.Peek();
    Console.WriteLine(v);//输出:true
    if(stack.Contains("123"))//Contains:确定某元素是否在Stack中
    {
        Console.WriteLine("存在123");//存在
    }
    #endregion

    #region 改/删
    //栈无法直接改变其中的某个元素 只能压栈(存)和弹栈(取)

    stack.Clear();//Clear:从Stack中移除所有对象
    //删除所有对象后重新加入达到所谓“改”的效果
    stack.Push("1");
    stack.Push(2);
    stack.Push("哈哈");
    #endregion
    
    #region 遍历
    Console.WriteLine(stack.Count);//Count:获取Stack中包含的元素数    
    
    //遍历顺序也是从栈顶到栈底的顺序
    //方式一:迭代器遍历
    foreach (object item in stack)
    {
        Console.WriteLine(item);//每次分别输出:哈哈 2 1
    }

    //方式二:转化为object数组
    object[] array = stack.ToArray();
    for(int i = 0; i < array.Length; i++)
    {
        Console.WriteLine(array[i]);//每次分别输出:哈哈 2 1
    }

    //方式三:循环弹栈
    while(stack.Count > 0)
    {
        object o = stack.Pop();
        Console.WriteLine(o);//每次分别输出:哈哈 2 1
    }
    #endregion
    
    Console.ReadLine();
}

3. Queue(队列)

Queue是一种先进先出的数据结构,它的本质也是object[]数组,只是封装了特殊的存储规则。

static void Main(string[] args)
{
    Queue queue = new Queue();

    #region
    queue.Enqueue(1);//Enqueue:将对象添加到Queue的末尾处
    queue.Enqueue("123");
    queue.Enqueue(1.4f);
    queue.Enqueue(new Program());
    #endregion

    #region
    object v = queue.Dequeue();//Dequeue:移除并返回位于Queue开始处的对象,Queue无元素时抛异常
    Console.WriteLine(v);//输出:1
    v = queue.Dequeue();
    Console.WriteLine(v);//输出:123
    #endregion

    #region
    v = queue.Peek();//Peek:返回位于Queue开始处的对象但不将其移除,Queue无元素时抛异常
    Console.WriteLine(v);//输出:1.4
    v = queue.Peek();
    Console.WriteLine(v);//输出:1.4
    
    if(queue.Contains(1.4f))//Contains:确定某元素是否在Queue中
    {
        Console.WriteLine("队列中存在1.4f");//输出
    }
    #endregion

    #region 改/删
    //队列无法直接改变其中的某个元素 只能进(存)和出(取)

    queue.Clear();//Clear:从Queue中移除所有对象
     //删除所有对象后重新加入达到所谓“改”的效果
    queue.Enqueue(1);
    queue.Enqueue(2);
    queue.Enqueue(3);
    #endregion

    #region 遍历
    Console.WriteLine(queue.Count);//Count:获取Queue中包含的元素数
    //方式一:迭代器遍历
    foreach(object item in queue)
    {
        Console.WriteLine(item);//每次分别输出:1 2 3
    }
    
    //方式二:转化为object数组
    object[] array = queue.ToArray();
    for(int i = 0; i < array.Length; i++)
    {
        Console.WriteLine(array[i]);//每次分别输出:1 2 3
    }
    
    //方式三:循环取出                                                                      
    while(queue.Count > 0)
    {
        object o = queue.Dequeue();
        Console.WriteLine(o);//每次分别输出:1 2 3
    }
    Console.WriteLine(queue.Count);//输出:0
    #endregion
        
    Console.ReadLine();
}

4. Hashtable(哈希表)

Hashtable(又称散列表、散列表)是基于键的哈希代码组织起来的 键/值对,使用键来访问集合中的元素,主要作用是提高数据查询的效率。Hashtable中的每个元素都是一个存储在DictionaryEntry对象中的键值对,且不是按顺序存储的

static void Main(string[] args)
{
    Hashtable hashtable = new Hashtable();
    
    #region
    hashtable.Add(1, "123");//Add:将带有指定键和值的元素添加到Hashtable中,注意这里的添加的键是唯一的,不能重复添加
    hashtable.Add("123", 2);
    hashtable.Add(true, false);
    hashtable.Add(false, true);
    
    hashtable[11] = 20;//直接赋值添加
    #endregion

    #region
    hashtable.Remove(1);//Remove:从Hashtable中移除带有指定键的元素
    hashtable.Remove(2);//移除不存在的键时,不会抛异常
    hashtable.Clear();//Clear:从Hashtable中移除所有元素
    #endregion
    
    hashtable.Add(1, "123");
    hashtable.Add(2, "1234");
    hashtable.Add(3, true);
    hashtable.Add("123456", 12);
    hashtable[11] = 20;
    
    #region
    Console.WriteLine(hashtable[2]);//输出:1234 通过键进行查找
    Console.WriteLine(hashtable[4]);//输出:     通过查找不存在的键时,不会抛异常返回“”

    if (hashtable[1] != null)
    {
        Console.WriteLine("hashtable存在:" + hashtable[1]);//输出:hashtable存在:123
    }
    if(hashtable.Contains(2))
    {
        Console.WriteLine("存在键为2的键值对");//输出
    }
    if(hashtable.ContainsKey(3))
    {
        Console.WriteLine("存在键为3的键值对");//输出
    }

    if(hashtable.ContainsValue("1234"))
    {
        Console.WriteLine("存在值为1234的键值对");//输出
    }
    #endregion

    #region
    //只能改 键对应的值内容 无法修改键
    Console.WriteLine(hashtable[1]);//输出:123
    hashtable[1] = 200;
    Console.WriteLine(hashtable[1]);//输出:200

    Console.WriteLine(hashtable[11]);//输出:20
    #endregion

    #region 遍历
    Console.WriteLine(hashtable.Count);//Count:获取包含在Hashtable中的键/值对的数目

    //方式一:遍历哈希表中的所有键值对的键
    foreach(object item in hashtable.Keys)
    {
        Console.WriteLine(item + ":" + hashtable[item]);//每次分别输出:123456:12  11:20  3:True  2:1234  1:200
    }
    
    //方式二:遍历哈希表中的所有键值对的值
    foreach(object item in hashtable.Values)
    {
        Console.WriteLine(item);//每次分别输出:12  20  True  1234  200
    }
    
    //方式三:遍历哈希表中的所有键值对
    foreach(DictionaryEntry item in hashtable)
    {
        Console.WriteLine(item.Key + ":" + item.Value);//每次分别输出:123456:12  11:20  3:True  2:1234  1:200
    }
    
    //方式四:迭代器遍历法
    IDictionaryEnumerator idEnumerator = hashtable.GetEnumerator();
    bool flag = idEnumerator.MoveNext();
    while(flag)
    {
        Console.WriteLine(idEnumerator.Key + ":" + idEnumerator.Value);//每次分别输出:123456:12  11:20  3:True  2:1234  1:200
        flag = idEnumerator.MoveNext();
    }
    #endregion

    Console.ReadLine();
}

小结

四个常用的集合类型的存储都会涉及装箱拆箱问题,会消耗性能。
当往其中进行值类型存储时就是在装箱,当将值类型对象取出来并转换使用时,就是存储拆箱。
例如:

ArrayList array = new ArrayList();
int j = 1;
array[0] = j;//装箱:值类型->object
j = (int)array[0];//拆箱:object -> 值类型

因为作者精力有限,文章中难免出现一些错漏,敬请广大专家和网友批评、指正。

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值