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

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

常见的容器：

参考文献：
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);
      //查看元素是否存在
      Debug.Log(arr.Contains("123"));
      //正向查找元素位置（找得到返回index，找不到返回 -1）
      Debug.Log(arr.IndexOf("123"));
      //反向查找元素位置
      Debug.Log(arr.LastIndexOf("123"));


      //改
      arr = "999";

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

      i = (int)arr;//拆箱
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);
      //查看是否存在键（contains和containskey一样）
      Debug.Log(h.ContainsKey(1));
      //查看是否存在值
      Debug.Log(h.ContainsValue("12323"));

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

[*]遍历，
      //长度
      int l = h.Count;

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

      //遍历所有值
      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相同。
页: [1]
查看完整版本: Unity面试问题学习笔记（7）——C#的容器