Unity面试问题学习笔记（7）——C#的容器

Ilingis

常见的容器：

参考文献：
1.List容器：

参考资料：

• 类似于C++的vector，顺序结构不是链式结构。
  
• Add类似push_back，在末尾添加元素
  
• Insert类似Insert，在选中的位置处添加元素
  
• Remove类似erase，选择位置删除元素
  
• Contains，可以查找list中是否有指定元素
  
• Sort，排序函数，类似sort，不需要给起始点和重点，需要写一个特殊的类继承IComparer，并重写Compare（）方法。（注意return正数是升序，return负数是降序）
  

class myComparer : IComparer<int>
{
    public int Compare(int a, int b)
    {
        //+是升序，-是降序
        return -a.CompareTo(b);
    }
}

• Reverse，类似reverse函数，将list反转
  
• Clear，类似clear，清空
  
• Count，类似size，统计list的元素数量
  
• Find，参数可以填一个函数或直接用lamda函数，返回的是满足条件的第一个元素；FindLast返回最后一个满足条件的元素；FindAll找到所有满足条件的元素。
  

        int ans = m_List.Find(i =>
        {
            if (i >= 3)
                return true;
            else
                return false;
        });
//i是代指list中的每个元素，也就形参名，可以自定义
2.String容器：

• 本质上是char数组
  
• 常用方法：
  

        //初始化
        string s = "123456";
        //转为char数组
        char[] c = s.ToCharArray();
        //字符串长度
        int l = s.Length;
        //字符串拼接
        //string ss = string.Format("{0}是大傻逼", l);
        string ss = string.Format($"{{0}}是大傻逼", l);
        Debug.Log(ss);
        //返回指定字符的位置（int）,从0开始
        int i = s.IndexOf("2");
        Debug.Log(i);
        int j = s.LastIndexOf("5");
        Debug.Log(j);
        //移除指定位置后的字符（第一个参数为指定位置的index，第二个参数为删除元素的个数）
        //注意，删除元素包含指定index的那个元素
        string sss = s.Remove(0, 2);
        Debug.Log(sss);
        //替换指定的字符
        string ssss = s.Replace("1", "0");
        //大小写转换
        string s5 = s.ToLower();
        string s6 = s.ToUpper();
        //字符串截取（第一个参数是指定位置的index，第二个参数为截取元素的个数）
        //注意，不会自动判断是否越界，需要自己来控制
        string s7 = s.Substring(0, 4);
        Debug.Log(s7);
        //字符串分割
        Debug.Log(".........................");
        string s8 = "1,2,3,4,5,6,7";
        string[] sGroup = s8.Split(new char[] { ',' });
        foreach (string k in sGroup)
        {
            Debug.Log(k);
        }
3.ArrayList容器：

• 引用，using System.Collections；
  
• 本质，ArrayList是一个C#为我们封装好的类，它的本质上是一个object类型的数组。ArrayList类帮助我们实现了很多方法，比如数组的增删查改。
  
• 申明，
  

ArrayList arr = new ArrayList();

• 增删查改，
  

        //增（可以添加任意类型的变量）
        arr.Add(1);
        arr.Add("123");
        arr.Add(new object());
        ArrayList arr2 = new ArrayList() { 1, 2, 3, "123", true };
        //批量增加，把另一个list里的内容加到原list的后面
        arr.AddRange(arr2);
        //插入（第一个元素是index，第二个元素是要插入的内容）
        arr.Insert(0, "2");
        Debug.Log(arr.IndexOf("2"));


        //删
        //从头找，找到第一个符合的元素，将其删除
        arr.Remove(1);
        //指定位置的元素，进行删除
        arr.RemoveAt(0);
        //清空
        arr.Clear();


        //查
        //得到指定位置的元素
        Debug.Log(arr[0]);
        //查看元素是否存在
        Debug.Log(arr.Contains("123"));
        //正向查找元素位置（找得到返回index，找不到返回 -1）
        Debug.Log(arr.IndexOf("123"));
        //反向查找元素位置
        Debug.Log(arr.LastIndexOf("123"));


        //改
        arr[0] = "999";

• 装箱拆箱，Arraylist本质上是一个可以自动扩容的object数组，由于万物之父来存储数据，自然存在装箱拆箱。当往其中进行只类型存储时就是在装箱（栈转去堆），当将值类型对象取出来转换使用时，就存在拆箱（堆转去栈）。
  

        //装箱拆箱
        int i = 1;
        arr[0] = i;//装箱

        i = (int)arr[0];//拆箱
4.Stack容器：

• 本质，stack也就是栈，和C++的stack类似，是一个object数组，也是以先进后出的顺序对数据进行存储。
  
• 申明，
  

Stack s = new Stack();

• 增删查改，
  

        //增
        //压栈（只能一个个放，一个个取）
        s.Push(1);
        s.Push("123");
        s.Push(true);

        //删除
        //弹栈（注意，和C++的pop不一样，有返回值，弹出栈顶的同时也把它返回了
        object o = s.Pop();

        //查
        //只能看栈顶，和C++的top类似
        object oo = s.Peek();
        //和ArrayList一样，判断栈中是否存在具体元素
        Debug.Log(s.Contains(1));

        //改
        //只能压或弹，要么就是清空
        s.Clear();
        s.Push(1);
        s.Push(123);
        s.Push("HHH");

• 遍历，
  

        //长度
        int l = s.Count;

        //不能for遍历 foreach遍历的顺序也是从栈顶到栈底
        foreach(object x in s)
        {
            Debug.Log(x);
        }

        //将栈转成数组就可以for遍历
        object[] arr3 = s.ToArray();
        for(int i = 0;i < arr3.Length; i++)
        {
            Debug.Log(arr3);
        }

        //循环弹栈
        while(s.Count > 0)
        {
            object y = s.Pop();
        }

• 装箱拆箱，同ArrayList。
  

5.Queue容器：

• 本质，和C++的queue类似，先进先出，都是object类型。和stack的操作类似，就是出入顺序不一样。栈是先进后出，队列是先进先出。
  
• 申明，和stack一样。
  
• 增删查改，
  

        //增
        q.Enqueue(1);
        q.Enqueue("123");
        q.Enqueue(true);

        //取
        //从头取一个元素
        object oq = q.Dequeue();

        //查
        oq = q.Peek();
        Debug.Log(q.Contains("123"));

        //改
        q.Clear();

• 遍历，和stack一样。
  
• 装箱拆箱，和stack一样。
  

6.HashTable容器：

• 本质，散列表，是基于键的哈希代码组织起来的键值对，主要作用是提高数据查询的效率，使用键来访问集合中的元素。
  
• 申明，
  

Hashtable h = new Hashtable();

• 增删查改，
  

        //增
        //键是唯一的，不能出现相同键，否则会直接报错
        h.Add(1, "123");
        h.Add(2, true);
        h.Add(3, 1.2f);

        //删
        //只能通过键来删除
        h.Remove(1);
        //删除不存在的键没梵音
        h.Remove(2);
        //直接清空
        h.Clear();

        //查
        //通过键查看值，找不到会返回空
        Debug.Log(h[1]);
        //查看是否存在键（contains和containskey一样）
        Debug.Log(h.ContainsKey(1));
        //查看是否存在值
        Debug.Log(h.ContainsValue("12323"));

        //改
        //通过键改值 注意不能直接改键
        h[1] = 50;

• 遍历，
  

        //长度
        int l = h.Count;

        //遍历所有键
        foreach(object item in h.Keys)
        {
            Debug.Log(item);
            Debug.Log(h[item]);
        }

        //遍历所有值
        foreach(object item in h.Values)
        {
            Debug.Log(item);
        }

        //键值对一起遍历
        foreach(DictionaryEntry item in h)
        {
            Debug.Log(item.Key + " " + item.Value);
        }

        //迭代器遍历法
        var iter = h.GetEnumerator();
        bool flag = iter.MoveNext();
        while (flag)
        {
            Debug.Log(iter.Key + " " + iter.Value);
            flag = iter.MoveNext();
        }

• 装箱拆箱，和queue，stack相同。