Unity-C#基础学习12

第12节：数组  集合 List ArrayList Stack  字典  哈希表（算是都有涉猎吧）

(本文单开一篇集合以表对集合的关注。。。写到现在c#基础已经讲了七七八八了，应该还有很多不足，后期会慢慢补充的，但是讲完之后后续应该要扩展到Unity了，毕竟这个是为了Unity做基础，如果有什么不足希望大家多多指教，多多谅解！！在此蟹蟹啦。)

本节干货满，直接上代码吧！

using System;
using System.Collections;
using System.Collections.Generic;

namespace List 
{
    class MainClass
    {
        public static void Main (string[] args)
        {
            //数组的缺点：数组初始化以后，容量固定；数组中存放的数据单一
            /*
             * 一、集合：提供一种灵活的数据的处理办法，与数组不同，
             * 在处理对象时，可以根据程序的更改动态地增长或者收缩内存空间
             * 
             * 注意：集合是类，因此在使用时，需要先声明对应的实例，才能在集合中添加元素
             * 
             * 集合分类：1、泛型集合；2、非泛型集合
             * 使用泛型集合需要引入：System.Collections.Generic
             * 非泛型集合需要引入：System.Collections
             * 
            */
            //ArrayList的使用
            //1.实例化一个数组列表
            ArrayList arrList = new ArrayList ();
            //2.常用方法
            arrList.Add (1);
            arrList.Add (1.23);
            arrList.Add ("老王");
            arrList.Add ("炸鸡");
            arrList.Add (2);
            arrList.Add (3);
            arrList.Add (4);
            //3.遍历数组列表
//            foreach (var item in arrList) {
//                Debug.Log (item);
//            }
            //4.插入一个元素
            arrList.Insert(0,"老弟");
            //5.移除指定元素
            arrList.Remove("老王");
            //6.移除指定下标的元素
            arrList.RemoveAt(1);      
            //7.移除指定范围的元素，从指定下标为3的元素开始移除3个
            arrList.RemoveRange(3,3);
            //8.将整个集合元素反转
            arrList.Reverse();
            //9.从指定位置开始，反转指定个数各元素
            arrList.Reverse(0,3);
            //10.判断当前集合是否包含某个元素
//            if (arrList.Contains("老弟")) {
//                Debug.Log ("厉害了");
//            }
            //11.集合包含元素个数
//            Debug.Log("集合元素为：{0}",arrList.Count);
//            Debug.Log (arrList[0]);
            //12.清楚所有元素
            arrList.Clear();
            /*
             * ArrayList的特点：
             * 1.支持自动改变存储空间大小
             * 2.可以灵活插入元素、删除元素、访问元素
             * 3、不是强类型
            */

            /*Stack
            */
            //1.初始化Stack对象
            Stack sta=new Stack();
            //常用方法
            //2.入栈，即将对象存放到栈的顶部
            sta.Push("挖个坑");
            sta.Push("埋点土");
            sta.Push("数个一二三四五");
            sta.Push("农民的土");
            sta.Push("农民的地");
            sta.Push ("种啥都长人民币");
            //栈内部可以存放空对象，但是null必须写上
            //sta.Push(null);
            //3.出栈，返回并移除Stack顶部的元素
            Debug.Log (sta.Pop());
            //4.查看，返回栈顶的元素，但是不移除
            Debug.Log (sta.Peek());
            //5.判断指定元素是否在栈中
            if (sta.Contains("农民的土")) {
               Debug.Log ("土还在");
            }
            //6.获取栈的元素个数
            Debug.Log ("sta个数为：{0}",sta.Count);
            //7.将栈转成数组
            object[] objArr=sta.ToArray ();
            for (int i = 0; i < objArr.Length; i++) {
               Debug.Log (objArr[i]+" ");
            }
            //8.将栈中的元素拷贝到某个数组中
            //第一个参数：是拷贝过去的目标对象数组
            //第二个参数：从这个参数开始
            object[] arr=new object[10];
            sta.CopyTo (arr, 5);
            for (int i = 0; i < arr.Length; i++) {
                Debug.Log(arr[i]+" ");
            }
            //9.移除栈中所有元素
            sta.Clear();

            //遍历栈中的元素
            foreach (var item in sta) {
                Debug.Log(item);
            }

            /*Stack的使用总结：
             * 1.后进先出（LIFO）的一种数据结构
             * 2.随着向Stack中添加元素，栈的容量通过重新分配内存按需自动增加
             * 3.Stack中接受存储null作为有效元素，
            */

            //Queue 队列的使用
            //1.实例化对象
            Queue queue=new Queue();
            //常用方法
            //2.将对象存放到队列中，将元素放到队列底部
            queue.Enqueue("床前明月光");
            queue.Enqueue("疑是地上霜");
            queue.Enqueue("举头望明月");
            queue.Enqueue("低头思故乡");
            //3.返回并移除队列中的顶部的元素
            Debug.Log (queue.Dequeue());
            //4.返回队列顶部的元素，而不移除
            Debug.Log ("顶部元素：{0}",queue.Peek());
            //5.判断是否存在某个元素
            if (queue.Contains("低头思故乡")) {
                Debug.Log ("老王");
            }
            //6.获取队列中元素的个数
            Debug.Log ("元素个数：{0}",queue.Count);
            //7.将队列转成数组
            object[] queueArr = queue.ToArray();
            for (int i = 0; i < queueArr.Length; i++) {
                Debug.Log (queueArr[i]);
            }
            //8.从指定位置开始拷贝元素到指定数组
            //9.清楚队列所有元素
            queue.Clear();

            Console.WriteLine ("**********分割线**********");
            //遍历
            foreach (var item in queue) {
                Debug.Log (item);
            }
            /*Queue的使用总结
             * 1.先进先出（FIFO）的一种数据结构
             * 2.随着Queue中元素的添加，内存空间会自动增加
             * 3.Queue接受存放null作为有效元素，并且允许元素重复
             * 4.在后续讲到AI寻路时会用到Queue
            */

            /*字典的使用
            用来存储具有一一对应的数据的集合
            使用Key-value(键值对)的形式来存储数据
            字典中key是唯一的，不能重复，value是个变量，也可以是对象
            字典是一个泛型集合，实例化对象时，必须指定key和Value的类型 
            */
            //1.实例化一个字典对象，表示：key是字符串类型，value是int类型
            Dictionary<string,int> dic = new Dictionary<string, int> ();
            //常用方法
            //2.添加键值对元素
            dic.Add("拔罐",100);
            dic.Add ("足疗技师",98);
            dic.Add ("踩背", 80);
            dic.Add ("刮痧", 120);
            dic.Add ("大保健", 999);

            //3.获取指定的Key相对应的Value
            //如果字典中包含传入的Key对应的键值对，那么返回为true，并且将这个key对应的value放到输出参数中
            //变量valu用来存放字典中出入key对应的value
            int valu=0;
            bool isExit = dic.TryGetValue ("大保健",out valu);
            if (isExit) {
                Debug.Log ("大保健的价格为:{0}", valu);
            } else {
                Debug.Log ("没有");
            }
            //4.判断字典中是否存在某个key
            if (dic.ContainsKey ("拔罐")) {
                Debug.Log ("还不错");
            }
            //5.判断字典中是否存在某个值
            if (dic.ContainsValue(999)) {
                Debug.Log ("叫两个");
            }
            //6.移除字典中某个键值对
            if (dic.Remove("大保健")) {
                Debug.Log ("移除成功");
            }
            //7.获取字典中键值对的个数
            Debug.Log  ("字典中键值对个数：{0}",dic.Count);
            //8.获取字典当中所有的keys值
            Dictionary<string,int>.KeyCollection keys=dic.Keys;
            foreach (var item in keys) {
                Debug.Log  (item);
            }
            //9.获取字典当中所有的value值
            Dictionary<string,int>.ValueCollection values=dic.Values;
            foreach (var item in values) {
                Debug.Log  (item);
            }
            //10.遍历整个字典元素
            foreach (var item in dic) {
                Debug.Log  (item.Key+"--"+item.Value);
            }

            //练习：用户输入10个姓名，可以重复输入同一个姓名，要求输出每个姓名
            //并且输出每个姓名出现的次数
            //改变字典中已用的key的value值：字典名[key] = 新值；
            //思路：把姓名作为字典的key值，名字出现的次数当做value值，每次
            //输入后判断是否已经存在这个名字，如果存在Value加1，如果不存在
            //添加到字典当中，Value设置为1
            //创建字典
            Dictionary<string,int> nameDic =
                new Dictionary<string, int> ();
            //创建循环，开始输入名字,创建变量name来存放输入的名字
            string name = "";
            //定义循环变量
            int count = 0;
            while (count < 10) {
                //保存用户输入的名字
                name = Debug.Log();
                int times = 0;

                bool have = nameDic.TryGetValue (name, out times);
                //判断是否存在
                if (have) { 
                    times++;
                    //更新字典中key-value的值
                    nameDic [name] = times;
                } else {
                    //说明之前没出现这个名字,直接添加到字典中
                    nameDic.Add (name, 1);
                }
                count++;
            }
            //遍历字典
            foreach (var item in nameDic) {
                Debug.Log  (item.Key + "输入了：" +
                    item.Value + "次");
            }

            //List<T>类
            //1.初始化一个List对象
            List<int> list=new List<int>();
            //常用方法
            //1.添加元素
            list.Add(1);
            list.Add(2);
            list.Add(3);
            //通过一个数组添加元素
            int[] arr1={6,5,5,6};
            list.AddRange (arr1);
            //2.通过下标来访问list元素
            list[0]=6;
            //3.插入元素，在指定的下标位置，插入指定元素
            list.Insert(0,8);
            //4.移除
            list.Remove(6);
            //list.RemoveAll (it => it % 2 == 0);
            list.RemoveAt(0);
            list.RemoveRange (0, 1);
            //5.将整个存储列表进行反转
            list.Reverse();
            //6.获取指定元素的下标
            Console.WriteLine (list.IndexOf(6));
            //获取指定元素最后一个匹配项的下标
            Console.WriteLine (list.LastIndexOf(6));
            //7.默认排序
            list.Sort();
            //8.判断是否包含某个元素
            Debug.Log  (list.Contains (5));
            //9.元素个数
            Debug.Log  (list.Count);

            foreach (var item in list) {
                Debug.Log  (item+"  ");
            }
            Debug.Log  ();

            /*
             * 1.和ArrayList相比，List<T>类在大多情况下执行效率更高，并且是类型安全的，如果List中的T是引用类型
             * 两个类的行为完全相同，但是如果T类型为值类型， ArrayList需要考虑到拆箱的操作
            */


            //哈希表：是一个中类似字典的集合，也是采用键值对的形式来管理数据
            //1.实例化对象
            Hashtable hashtable=new Hashtable();
            //2.添加元素
            hashtable.Add("AA",11);
            //哈希表中不能直接得到值
            int a=(int) hashtable ["AA"];
            /*
             * SortList:排序列表，相当于是Hashtatbleh和Array的混合，该集合存储的行为类似Hashtable，但是
             * 当使用索引获取对应元素的时候，行为又类似于Array
             * 
             * SortList在内部维护两个数组，一个数组用于存储键（Key）
             * 另一个数组用于关联的值，每个元素都可以作为一个DictionaryEntry,对象进行访问时，访问的是键/值
             * 键不能为空
             * 
             * SortList中Key是按照特定的ICompare来进行排序
            */
            SortedList<string,string> sorelist = new SortedList<string, string> ();
            sorelist["c"]="2";
            sorelist ["b"] = "3";
            sorelist ["d"]="1";
            sorelist["a"]="4";
            Console.WriteLine ("--遍历有序列表--");
            foreach (var item in sorelist) {
                Debug.Log  (item.Key+" "+item.Value);
            }

            /*
             * 索引器：是一种特殊的类成员，可以实现让对象以类似数组的方式来存储数据，让程序更直观
             * 索引器允许类的实例按照和数组相同的方式进行索引取值
             * 索引器和属性相似，不同的是索引器的访问是带参数的
            */
            //创建一个对象
            IndexerClass indexer=new IndexerClass ();
            //使用索引器来存储数据
            indexer[0]="老王";
            indexer[1]="老李";

            indexer ["大泽"] = 2;
            indexer ["小泽"] = 3;
            Debug.Log ("aaa= "+indexer["小泽"]);
            Console.WriteLine ("bbb= "+indexer["老王"]);

            Debug.Log  (indexer[0]);


        }
    }
}