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

Ilingis · 发表于 2022-9-28 18:12

常见的容器：

参考文献：
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 = &#34;123456&#34;;
      //转为char数组
      char[] c = s.ToCharArray();
      //字符串长度
      int l = s.Length;
      //字符串拼接
      //string ss = string.Format(&#34;{0}是大傻逼&#34;, l);
      string ss = string.Format($&#34;{{0}}是大傻逼&#34;, l);
      Debug.Log(ss);
      //返回指定字符的位置（int）,从0开始
      int i = s.IndexOf(&#34;2&#34;);
      Debug.Log(i);
      int j = s.LastIndexOf(&#34;5&#34;);
      Debug.Log(j);
      //移除指定位置后的字符（第一个参数为指定位置的index，第二个参数为删除元素的个数）
      //注意，删除元素包含指定index的那个元素
      string sss = s.Remove(0, 2);
      Debug.Log(sss);
      //替换指定的字符
      string ssss = s.Replace(&#34;1&#34;, &#34;0&#34;);
      //大小写转换
      string s5 = s.ToLower();
      string s6 = s.ToUpper();
      //字符串截取（第一个参数是指定位置的index，第二个参数为截取元素的个数）
      //注意，不会自动判断是否越界，需要自己来控制
      string s7 = s.Substring(0, 4);
      Debug.Log(s7);
      //字符串分割
      Debug.Log(&#34;.........................&#34;);
      string s8 = &#34;1,2,3,4,5,6,7&#34;;
      string[] sGroup = s8.Split(new char[] { &#39;,&#39; });
      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(&#34;123&#34;);
      arr.Add(new object());
      ArrayList arr2 = new ArrayList() { 1, 2, 3, &#34;123&#34;, true };
      //批量增加，把另一个list里的内容加到原list的后面
      arr.AddRange(arr2);
      //插入（第一个元素是index，第二个元素是要插入的内容）
      arr.Insert(0, &#34;2&#34;);
      Debug.Log(arr.IndexOf(&#34;2&#34;));

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

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

      //改
      arr[0] = &#34;999&#34;;

装箱拆箱，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(&#34;123&#34;);
      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(&#34;HHH&#34;);

遍历，

      //长度
      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(&#34;123&#34;);
      q.Enqueue(true);

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

      //查
      oq = q.Peek();
      Debug.Log(q.Contains(&#34;123&#34;));

      //改
      q.Clear();

遍历，和stack一样。

装箱拆箱，和stack一样。

6.HashTable容器：

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

申明，

Hashtable h = new Hashtable();

增删查改，

      //增
      //键是唯一的，不能出现相同键，否则会直接报错
      h.Add(1, &#34;123&#34;);
      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(&#34;12323&#34;));

      //改
      //通过键改值注意不能直接改键
      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 + &#34; &#34; + item.Value);
      }

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

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

		自动登录	找回密码
密码			立即注册