C#学习第六天

 

C#中数组：（数组长度为0并不代表数组为null）

c#中的数组初始化（赋值）方式有2种。动态初始化、静态初始化。

动态初始化：指定长度，元素初始值由编译器指定（0 false null）。

例如：int[] arrint = new int[10];指定数组有10个元素，并初始化各元素的值（0）。

静态初始化：指定初始化值，长度由编译器根据初始化的元素个数确定。

例如 int[] arrint = new int[]{1,2,3}；长度编译器推断出是3。

和Java不同，C#允许静态初始化时指定数组元素个数即长度。例如：int[] arr = new int[3]{1,2,3};注意这种方式，指定的长度必须与初始化元素个数相等。

          int[] intarr;
          //  intarr = {1,2,3};这种方式只能用于声明并初始化的情况下
           intarr = new int[] { 1, 2, 3, 4, 5 }; //ok

 

   Object[] oo = { "你好", 1, 2, true };//自动装箱
            for (int i = 0; i < oo.Length; i++)
            {
                Console.WriteLine(oo[i]);
            }

 

隐式数组类型：（var）

 var ints = new[] { 1,8,9,0}; var必须用于初始化变量（以推断其类型）。

在声明隐式数组时，右侧初始化必须以new[]开始，{}中是各元素的值。如果原始是匿名类型，必须所有的匿名类型类型一致。例如如下：

var persons = new[]{new{name="张三",sex="男"},new{name="李四",sex="男"}};

 

枚举enum：

由于枚举值都对应一个数字，故枚举可进行数字运算操作。

例如 enum Type{水果,电器,车,食品}

Type t = Type.水果;t++则对应于Type.电器;

   for (lib.Sex i = lib.Sex.男; i <= lib.Sex.女; i++)
            {
                Console.WriteLine(i+":"+(int)i);//打印出男:280；女：281.注：枚举值男=280.

            }

 集合：

 //集合 ArrayList使用
            ArrayList al = new ArrayList(3);
            foreach (int i in new int[] { 10, 20, 1, 9, -10, 8, 2, 5, 7, 0, 3, -5 })
            {
                al.Add(i);//自动装箱i为object
            }
            //打印出10, 20, 1, 9, -10, 8, 2, 5, 7, 0, 3, -5,
            foreach (object o in al)
            {
                Console.Write("{0},",o);
            }
            Console.WriteLine("");

            al.Insert(0, 128);
            al.Insert(al.Count, 188);
            al.Insert(1, 2);
            //打印出128,2,10, 20, 1, 9, -10, 8, 2, 5, 7, 0, 3, -5,188,
            foreach (object o in al)
            {
                Console.Write("{0},", o);
            }
            Console.WriteLine("");

            al.Remove(128);//移除值等于128的第一个元素
            al.Remove(2);
            //打印出10, 20, 1, 9, -10, 8, 2, 5, 7, 0, 3, -5,188,
            foreach (object o in al)
            {
                Console.Write("{0},", o);
            }

  //队列使用
            Queue q = new Queue();
            for (int i = 0; i < 10; i++)
            {
                q.Enqueue(i);//自动装箱为object
                Console.WriteLine(i+"入队");
            }
            //遍历队列
            foreach (Object i in q)
            {
                Console.WriteLine(i);
            }
            Console.Write("\n");

            //出队列
            //int k = q.Count;
            for (; q.Count>0; )
            {
                Console.WriteLine("{0} 出队列！", q.Dequeue());
            }
           
            /*while (q.Count > 0)  OK
            {
                int num = (int)q.Dequeue();//拆箱
                Console.WriteLine("{0} 移除队列！",num);
            }
            */

 //栈的使用

            Stack s = new Stack();
            foreach (int i in new int[] { 1, 2, 3, 4, 5 })
            {
                s.Push(i);//自动装箱为Object
                Console.WriteLine("{0}被压进栈",i);
            }

            //遍历栈 打印出5,4,3,2,1
            foreach (Object o in s)
            {
                Console.WriteLine("遍历到{0}",o);
            }

            //出栈(从栈顶删除元素),每删除一个元素，Count会自动变化
            while (s.Count > 0)
            {
                int num = (int)s.Pop();//拆箱
                Console.WriteLine("{0} 出栈（从栈删除）",num);
            }

 

 集合初始化器：

 只有实现了集合接口Add方法的集合类才能使用集合初始化器。格式 collectionType cl = new CollectionType(){obj1, obj2,……}。编译器会自动调用该类的Add方法把这些初始化器中的元素添加到集合中去。

例如 ArrayList al = new ArrayList(){1,2,3,4,5};编译器自动调用ArrayList实例的Add方法，把这些元素添加到集合中。队列Queue和栈Stack没有Add，故她们不能使用初始化器。

哈希表Hashtable和SortList可以如下使用初始化器：

Hashtable ht = new Hashtable(){  {"a",100},{"b",200}  };里面元素为匿名对象，key示例中的字符串“a”等，Value为100等。

 

            //哈希表和排序列表(里面元素为DictionaryEntry),键和值都是Object
            Hashtable ht = new Hashtable();
            ht["a"] = 100;
            ht["b"] = "字符串";
            foreach (DictionaryEntry o in ht)
            {

                Console.WriteLine("Key = {0};Value = {1}",o.Key,o.Value);//Key,Value都是Object，这是基本集合的特性。如ArrayList,Queue,Statck等元素都是Object。

            }

            ht["a"] = 100;
            ht["b"] = "字符串001";//覆盖原来的Key对应的值
            foreach (DictionaryEntry o in ht)
            {

                Console.WriteLine("Key = {0};Value = {1}", o.Key, o.Value);

            }

            //ht.Add("a", 500);//抛出异常，因为通过Add添加DictionaryEntry，如果Key存在，则异常。但通过[]方式不抛出而是覆盖原有值。

            /*
             * SortedList 自动排序
             */
            SortedList sl = new SortedList();
            sl.Add("a", 100);
            sl.Add("c","C");
            sl.Add("b", true);

            //打印顺序是a,b,c
            foreach (DictionaryEntry entry in sl)
            {
                Console.WriteLine("Key = {0};Value = {1}", entry.Key, entry.Value);
            }
            Console.WriteLine("=================================");
            //集合初始化器
            //Queue q0 = new Queue() { 1, 5, 6 };Queue,Stack不包含Add定义，所以不能使用集合初始化器
            ArrayList al0 = new ArrayList() { 10, 5, 8, 9, "中国", true };
            foreach (Object o in al0)
            {
                Console.WriteLine(o);
            }