Unity中常用数据结构的，特点，优缺点，实例。_unity 数据结构

Unity中常用的数据结构有一下几种：Array，ArrayList，List，LinkedList，Queue，Stack，Dictionary；就一一分析一下他们的特点，优缺点和用法吧，要是有错误的地方欢迎指正；

一，数组（Array）

特点：

1. 数组属于线性结构，在内存中是连续存放的。
2. 数组的元素类型必须相同。
3. 数组可以直接通过下标访问。
4. 数组的查找速度非常快，新增和删除速度慢。
5. 数组在初始化时要指定数组长度。

优缺点：

优：存储在连续内存上；内容都是相同类型；可以通过下标访问，查找的速度很快；

缺：必须指定其长度，元素插入也不方便（过长浪费内存，多段会溢出），新增和删除也很慢；

实例：

 string[] arr;
    void Start()
    {
        //必须初始一个长度；
        arr = new string[3];
        //赋值；
        arr[0] = "abc";
        arr[1] = "bm";
        arr[2] = "r";
        //修改；
        arr[2] = "bb";
    }

二，动态数组(ArrayList)

特点：

1. ArrayList的底层其实就是一个数组。
2. ArrayList在声明时不必指定长度，会根据存储的数据动态的增加或减少长度。
3. ArrayList会把所有的元素都当做Object处理，因此可以存储不同数据类型的元素。
4. 插入和删除一个元素时，会移动它之后所有元素的位置，效率低；
5. ArrayList是非类型安全的，在插入和删除元素时会进行拆箱和装箱问题，影响性能，效率低。

优缺点：

优：可动态增加和删除 ，可存储不同类型；

缺：类型不安全，因为存储的是不同类型，都会当Object来处理。插入值类型会发生装箱，索引取值会拆箱，影响性能，效率低。

实例：

 ArrayList arrayList;
    void Start()
    {
        arrayList = new ArrayList();
        //增加
        arrayList.Add("asdf");
        arrayList.Add(0);
        arrayList.Add('c');
        arrayList.Add(3);
        //删除
        arrayList.Remove(0);//按内容直接删除
        arrayList.RemoveAt(0);//按坐标删除
        //修改
        arrayList[0] = "asdfsdfa";
 
 
        for (int i = 0; i < arrayList.Count; i++)
        {
            Debug.Log(arrayList[i]);
        }
    }

三，List泛型

list在Unity中是比较常见的数据结构，因为ArrayList相当于Array的一个优化，List又相当于ArrayList的泛型类，成功解决的ArrayList装箱拆箱的问题，及安全又提升了效率；

特点：

1. List是ArrayList的泛型类。
2. 泛型List需要在声明时指定具体的类型。
3. 泛型List没有装箱和拆箱操作，因此List比ArrayList效率高而且类型安全。

优缺点：

优：Array和ArrayList结合，泛型规定了其类型，避免了拆装箱操作，及安全又提升了效率；

实例：

  List<int> numberList;
    void Start()
    {
        numberList = new List<int>();
        //增加
        numberList.Add(0);
        numberList.Add(5);
        numberList.Add(9);
        //删除
        numberList.Remove(0);
        //修改
        numberList[0] = 45;
    }

四，双向链表（LinkedList）

特点：

1. 链表的节点在内存中的空间是不连续的，每块空间称作一个节点，每个节点都存有一个前驱和后置指针，分别指向前一个节点和后一个节点，因此向链表中添加和删除元素的效果高，只需要更改相应节点的指针指向即可。
2. 链表的查找效率低。查找元素时不能通过下标进行访问，只能从头开始通过地址按顺序查找。

优缺点：

优：插入和删除操作无需调整结构容量，靠各个对象的指针决定，尤其是元素的数量不固定需要在两头插入时；

缺：最大的缺点是存储在内存空间不一定是连续的，无法利用下标查找。

实例：

 LinkedList<int> numLinkedList;
    void Start()
    {
        numLinkedList = new LinkedList<int>();
        //增加
        numLinkedList.AddLast(1);
        numLinkedList.AddLast(5);
        numLinkedList.AddLast(8);
        numLinkedList.AddFirst(78);//插入到第一个；
        numLinkedList.AddLast(0);//插入到最后一个；
 
        //删除
        numLinkedList.Remove(1);
        //获取元素只能从头按顺序遍历，不能通过下标查找；
        foreach (int item in numLinkedList)
        {
            Debug.Log(item);
        }
    }

五，Queue（队列）

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

特点：

1. 链表是先进先出的原则，最先进入的元素最先被访问，最后进入的元素最后被访问。
2. Enqueue入队列，Dequeue出队列并返回列首元素，Peek只返回列首元素。 

优缺点：

优：能对集合进行顺序处理（先进先出）。能接受null值，并且允许重复的元素。

缺：不能通过下标访问；

实例：

 Queue<string> strQueue;
    void Start()
    {
        strQueue = new Queue<string>();
        //将对象添加到 Queue 的结尾处。
        strQueue.Enqueue("星期日");
        strQueue.Enqueue(null);
        strQueue.Enqueue("星期一");
        strQueue.Enqueue("星期二");
        strQueue.Enqueue("星期三");
        strQueue.Enqueue("星期四");
        strQueue.Enqueue("星期五");
        strQueue.Enqueue("星期六");
        //移除并返回位于 Queue 开始处的对象。(及星期日)；最先进入的最先删除；
        strQueue.Dequeue();
 
        string str = strQueue.Dequeue();
        Debug.Log(str);
    }

一层一层的遍历子物体的时候用队列更方便；

 void Start()
    {
 
        GetAllChild(transform);
    }
 
    //使用队列实现
    public void GetAllChild(Transform parent)
    {
        //队列存放需要被遍历的节点
        //加入的逻辑为：当前节点的子节点，从第一个子节点到最后一个子节点顺序加入
        Queue<Transform> queue = new Queue<Transform>();
        queue.Enqueue(parent);
        while (queue.Count > 0)
        {
            //当前访问的子节点
            Transform current = queue.Dequeue();
            //输出当前节点的名字
            Debug.Log(current.name);
            //如果当前节点有子节点，则将其加入队列，留待以后遍历
            for (int i = 0; i < current.childCount; i++)
            {
                queue.Enqueue(current.GetChild(i));
            }
        }
    }

队列还可以，对消息或事件的发送与受理进行时间上的解耦。搜索消息队列就好，总之对于先进先出的数据，用队列处理最合适；

六，Stack（堆栈）

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

特点：

1. 堆栈是先进后出的原则，最先插入的元素最后被访问，最后插入的元素最先被访问。
2. Push入栈，Pop出栈并返回栈顶元素，Peek只返回栈顶元素。

优缺点：

同Queue，只是先进后出

实例：

 
    Stack<string> stack;
    void Start()
    {
        stack = new Stack<string>();
        //插入一个元素
        stack.Push("A");
        stack.Push("B");
        stack.Push("C");
        stack.Push("D");
        stack.Push(null);
        //移除顶部一个元素；D最后进入，D在顶部被移除；
       // stack.Pop();
        //返回在 Stack 的顶部的对象，但不移除它。
        string str = stack.Peek();
 
        Debug.Log(str);
        foreach (string item in stack)
        {
            Debug.Log(item);
        }
    }

七，Dictionary

特点：

1. 创建字典时需要指定key和value的数据类型。
2. 字典中的key值是唯一的，value的值可以不唯一。
3. 可以通过key快速查找对应的value，速度快，但是消耗内存。

优缺点：

优：（以内存换时间，需要键值对，快速操作）dictionary内部使用哈希表来存储元素对应的位置，通过哈希值快速从哈希表定位元素所在的位置索引，从而快速获取key对应的value；

缺：通过更多的内存开销来满足我们对速度的追求。

实例：

 Dictionary<int, string> dic;
    void Start()
    {
        dic = new Dictionary<int, string>();
        //赋值
        dic.Add(0, "a");
        dic.Add(1, "b");
        dic.Add(2, "c");
        dic.Add(3, "d");
        //移除
        dic.Remove(0);
        //根据key，获取到对应的value
        string str = dic[3];
 
        Debug.Log(str);
        //遍历字典；
        foreach (var item in dic)
        {
            Debug.Log(item.Value);
        }
    }