List<int >  li=new List<int>();//建立泛型集合

List<int>與陣列存放的型別都是固定的，但集合的長度是任意改變的，陣列的大小是固定的。當變數的數量不確定時，採用集合

            //陣列
            int[] nums=new int[10];//沒有賦值，裡面存放的是0
            string []  strs=new string[10];//未賦值，裡面存放的是null
            bool [] bols=new bool[10];// 未賦值，存放的是false

            List<int> list=new List<int>();//未賦值，裡面沒有資料
 

         List<int>與int陣列轉換
            li.Add(2);
            // 泛型集合中一個特點是可以轉成陣列
            li.Add(34);
            int [] nint=li.ToArray();
            foreach(int item in nint)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine();

List<string>與string陣列型別轉換

            string[] str = { "I","am","so","happy"};
            List<string> sl =str.ToList(); 
            foreach(string item in sl)
            {
                Console.WriteLine(item);
            }

記錄執行時間

            Stopwatch sw = new Stopwatch();
            sw.Start();
###   記錄執行時間的程式碼
            sw.Stop();
            Console.WriteLine(sw.Elapsed);
 

裝箱和拆箱

值型別----->引用型別：裝箱        拆箱：引用型別-------->值型別

兩種型別存在繼承關係，才有可能發生裝箱和拆箱。我們在判斷是否發生了拆裝箱，首先判斷這兩種資料型別是否存在繼承關係；裝箱型別必須與拆箱型別一致。

  string  str=“123”’，int num=Convert.ToInt32(str);  沒有發生裝箱或拆箱

繼承的話記憶體可能有交集，浪費時間

字典集合

        Dictionary<int, string> ndic=new Dictionary<int ,string>();
        ndic.Add(1,"OK");
        ndic.Add(2,"happy");
Dictionary<int,string>的兩種遍歷方式
        foreach (var item in ndic.Keys )
        {
            Console.WriteLine("{0}_____{1}",item,ndic[item]);
        }
        foreach (KeyValuePair<int ,string>  item in ndic)
        {
            Console.WriteLine("{0}---{1}", item.Key, item.Value);
        }

裝箱與拆箱

       {         
            //拆裝箱的最簡單例子.拆裝箱都耗費時間
            int n1 = 100;
            object ob = n1;// 裝箱
            int n2 = (int)ob;// 拆箱
            //double n3 = (int)ob;//這裡錯誤，必須用裝箱時的型別拆箱

            ArrayList arrayList = new ArrayList();//非泛型集合，沒有固定的型別，會發生拆裝箱，影響速度。
            Stopwatch stArrayList = new Stopwatch();
            stArrayList.Start();
            for (int i = 0; i < 100000;i++ )
            {
                arrayList.Add(i);//這裡add()裡面的引數是object型別，將int:i---->object,相當於發生了裝箱操作 
            }
            stArrayList.Stop();
            string timeArrayList = stArrayList.Elapsed.ToString();//記錄下執行的時間，記錄下拆裝箱的時間

            List<int> list=new List<int>();
            Stopwatch stList = new Stopwatch();
            stList.Start();
            for (int i = 0; i < 1000000;i++ )
            {
                list.Add(i);//List<int> 型別已確定，未發生裝箱
            }
            stList.Stop();
            string timeList = stList.Elapsed.ToString();

            //注意，下面沒有發生拆裝箱
            father fa = new son();//這個叫隱式型別轉換，不是裝箱
            son so = (son)fa;//這個叫顯示型別轉換，不是拆箱

            //方法過載時，如果具有該型別的過載，那麼就不叫拆箱或裝箱
            int n = 10;
            Console.WriteLine(n);  //沒有發生裝箱，因為方法過載。解釋一下，Console.WriteLine(object n)型別，但是因為方法過載了，存在Console.WriteLine(int n),所以呼叫此方法。

            //介面與引用型別發生拆裝箱，因為Int32繼承了介面
            IComparable com = n;//裝箱

            //拆裝箱的次數
            int num = 1;
            string str = "hello";
            double dou = 3.45;
            object obj = num;
            string st = str + num + dou;//相加相當於呼叫了string.Concat(object,object ,object ); 這裡發生了2次裝箱.string型別沒有發生拆裝箱
            string stt=num+","+(int)obj;//這裡發生了2次裝箱 ：num->object  (int)obj->object
            string str1=num.ToString()+num.GetType().ToString();//1次裝箱，GetType()不是虛方法，子類沒有重寫，所以呼叫的時候需要通過object.GetType()來呼叫.num-->object。沒有Int32.GetType(),但是有Object.GetType();也有Int32.ToString()

            Console.WriteLine("發生裝箱執行時間： {0}",timeArrayList);
            Console.WriteLine("未發生裝箱執行時間： {0}",timeList);
            Console.ReadKey();
         }
        public class father
        {
            string _name;
            public string Name
            {
                get { return _name; }
                set { _name = value; }
            }
        }
        public class son : father
        {
            string _name;
        }