C#基础03

   学习集合的一些知识。集合：泛型集合，非泛型集合;ArrayList,Hashtable,List<T>,Dictionary<k,v>等，还有一些集合的常用方法。

一：集合的介绍

1：集合的特点

  泛型集合     using System.Collections.Generic

  非泛型集合   using System.Collections

  *:对于数组而言，长度是一定的，可能造成内存的浪费，但是集合可以解决这个问题，它的长度是动态变化的。

  *:可以解除数组对数据类型的限制。集合里面的类型可以是不同的。其实集合里面保存的数据也是保存在数组里面，只是集合对数组进行了封装。

  *集合获取个数的时候用Count而数组用Length。

2：集合的分类

下面是常用的集合

            Hashtable aa = new Hashtable();
            Dictionary<int, int> aaa = new Dictionary<int, int>();
            ArrayList arr = new ArrayList();

* 键值对集合(“哈希表”) 集合里面有key和Value来存储值。每个key对应一个唯一的Value。

  {Hashtable,Dictionary<k,v>}

* ArrayList集合

            ArrayList arrayList = new ArrayList();
            arrayList.Add(10);
            //传递object类型
            arrayList.Add("10");                  
            //这里可以传递所有的集合类型，数组类型。
            arrayList.AddRange(arrayList);
            arrayList.AddRange(new int[]{1,4,5,5,5,5,5,});
            //通过下标来遍历元素
            //插入元素
            arrayList.Insert(0,"ahui");
           //删除元素  <删除第7个元素>  
            arrayList.RemoveAt(7);

            Console.WriteLine("{0}",arrayList.Capacity);
            Console.ReadKey();

3:集合删除元素的时候不能使用遍历删除，因为每一次集合的总量都会减少。直接调用Clear()来删除元素。

4:集合常用操作，添加，遍历，移除

属性

   Capacity(集合中可以容纳的个数，翻倍增长)

   Count(集合中实际存放的个数)

   Contains()包含某个元素

   ToArray()集合转换为数组

5：对于集合，别的类型装入之后，全部都会成为object类型保存。

6：对于集合可以调用Sort()进行排序，默认的情况是按升序进行的,我们可以实现它里面的IComparer接口，按照我们想排序的对象进行排序。因为调用Sort方法的时候它会找实现IComparer接口的类来进行排序。

   *在IComparer接口中我们要实现它的CompareTo方法，在这里面进行比较。

    class Person:IComparable
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Adress { get; set; }
        /// <summary>
        /// 实现IComparable接口,比较排序
        /// </summary>
        public int CompareTo(object obj)
        {
            var p = obj as Person;    //将object类型强转为Person类型
            if(p!=null)
            {
                return p.Age-this.Age;
            }
            return 0;
        }
    }

7:Hashtable集合

  *:这个集合和ArrayList不一样，它里面保存的格式是key,value形式的。（键和值），特点：key不能重复，是唯一的。只能通过键来获取值。

   var hash=new Hashtable();
   hash.Add("1","ahui");
   hash.Add("2",new Indo(){Name="张辉"});
   var dd = hash["2"] as Indo;
   Console.WriteLine(dd.Name);
   Console.ReadKey();

  *:Hashtable集合的遍历

    由于此集合没有Count属性，不能使用for循环来进行遍历，此时我们可以使用Foreach来进行。<因为它实现了IEnumerable接口>

    *：可以通过三种方法来找到值

   //遍历键
   foreach (var item in hash.Keys)
    {
      Console.WriteLine("键{0}--值{1}",item,hash[item]);
    }
   //遍历值
   foreach (var key in hash.Values)
    {
      Console.WriteLine(key);
    }
   //直接遍历键值对
   foreach (DictionaryEntry kv in hash)
   {
      Console.WriteLine("键{0}，值{1}",kv.Key,kv.Value);
   }
      Console.ReadKey();   

8：List<>集合

   在实际的操作中我们很少用之前的两种集合[ArrayList和Hashtable]，使用泛型集合[List<>和Dictionary<K,V>]，作用是之前的集合可以加各种类型，使用起来不是很方便，此时就有了这种泛型集合，只能保存特定的类型。而且扩展了很多的方法。

9:字符串生成器StringBuilder    一个可变的字符序列

   Var sb=new StringBuilder();

这个字符串生成器的好处就是字符串的长度是可变的，随着存储的长度的变化而变化。通过Append()来追加字符串填充到sb中..在你初始化一个StringBuilder 之后,它会自动申请一个默认的StringBuilder容量(默认值是16),这个容量是由Capacity来控制的.并且允许,我们根据需要来控制Capacity的大小,也可以通过Length来获取或设置StringBuilder 的长度；

Eg: StringBuilder可变字符串

           var sb = new System.Text.StringBuilder();
           sb.Append("123456789");                //添加一个字符串
             sb.Length = 30;                                 //设置容量为3
           Console.WriteLine(sb.ToString());     //这里输出:123

            sb.Length = 30;//重新设置容量为30
            Console.WriteLine(sb.ToString() + ",结尾");//这里在原来字符串后面补齐空格,至到Length的为30
            Console.WriteLine(sb.Length);//这里输出的长度为30

            StringBuilder sb = new StringBuilder();
            sb.Append(1);
            sb.Append(1);
            Console.WriteLine(sb.Capacity);
            Console.WriteLine(sb.Length);

10:StringBuilder<>集合

   Var str=new StringBuilder<char,char>;

  这个集合的类型必须指定，其里面的键的值不能相同。可以通过键找到相应的值，里面保存的是二维数组的形式。

二：练习题

eg1: 计算字符串中字母出现的次数，不区分大小写.

            string msg = "Welcome ,to China! world ! dsjfdsl.jfdsf";
            msg = msg.ToLower();
            Dictionary<char, int> dict = new Dictionary<char, int>();  //声明一个kv集合，k保存里面具体的值，v保存出现的次数。
            for (int i = 0; i < msg.Length; i++)
            {
                if (char.IsLetter(msg[i]))                //去掉除字母之外的东西
                {
                    if (dict.ContainsKey(msg[i]))     //dict里面有这个东西
                    {
                        dict[msg[i]]++;                   //表示把msg键加入，里面的值也加1
                    }
                    else
                    {
                        dict[msg[i]] = 1;
                    }
                }


            }
            //输出  注意类型为KeyValuePair
            foreach (KeyValuePair<char, int> kv in dict)
            {
                Console.WriteLine("{0}{1}", kv.Key, kv.Value);
            }
            Console.ReadKey();

eg2:将123转为大写.

            string str = "1q 2w 3e 4r 5t 6y 7u 8i 9o";
            var dict = new Dictionary<char, char>();
            string[] parts = str.Split(' ');          //Spilt把一个字符串以什么方式分割成字符串数组
            for (int i = 0; i < parts.Length; i++)
            {
                dict.Add(parts[i][0], parts[i][1]);   //这里的存储是二维数组
            }
            Console.WriteLine("请输入一个数：？？");
            string number = Console.ReadLine();
            StringBuilder sb = new StringBuilder();                //一个可变的字符序列
            for (int i = 0; i < number.Length; i++)
            {
                sb.Append(dict[number[i]]);
            }
            Console.WriteLine(sb.ToString());
            Console.ReadKey();

eg3 : 将int数组中的奇数放到一个新的int数组中返回

            int[] arry = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            List<int> arr = new List<int>();
            for (int i = 0; i < arry.Length; i++)
            {
                if (arry[i] % 2 != 0)
                {
                    arr.Add(arry[i]);
                }
            }
            int[] aa = arr.ToArray();
            for (int i = 0; i < aa.Length; i++)
            {
                Console.WriteLine(aa[i]);
            }
            Console.ReadKey();

eg4:随机产生10个数字，偶数，不重复

            ArrayList arr = new ArrayList();
            Random random = new Random(); //声明随机数
            var n = random.NextDouble();
            Console.WriteLine(n);
            while (arr.Count < 10)        //集合里面的数不能超过10
            {
                var num = random.Next(1, 101);
                if (num % 2 == 0 && !arr.Contains(num))    //偶数，不重复
                {
                    arr.Add(num);
                }
            }
            Console.WriteLine("总数为{0}", arr.Capacity);
            foreach (var item in arr)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

eg5:插入删除重复

            ArrayList arr1 = new ArrayList() { "a", "b", "c", "d", "e" };
            ArrayList arr2 = new ArrayList() { "d", "e", "f", "g", "h" };

            var arr3 = new ArrayList(new string[] { "11", "222", "1", "2" });

            //arr1.InsertRange(0,arr2);

            foreach (var item in arr1)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine("**************");

            for (int i = 0; i < arr2.Count; i++)
            {
                if (!arr1.Contains(arr2[i]))
                {
                    arr1.Add(arr2[i]);
                }
            }
            Console.WriteLine(arr1.Count);

            foreach (var item in arr1)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey(); 

eg6:随机产生10个数字，偶数，不重复

            ArrayList arr = new ArrayList();
            Random random = new Random(); //声明随机数
            var n = random.NextDouble();
            Console.WriteLine(n);
            while (arr.Count < 10)        //集合里面的数不能超过10
            {
                var num = random.Next(1, 101);
                if (num % 2 == 0 && !arr.Contains(num))    //偶数，不重复
                {
                    arr.Add(num);
                }
            }
            Console.WriteLine("总数为{0}", arr.Capacity);
            foreach (var item in arr)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

eg7 :List<>集合与Dictionary集合,修改上面的集，偶数使用List<>集合来实现

            List<int> Even = new List<int>();
            List<int> Oven = new List<int>();
            string sb = "1 2 3 4 5 6 7 8 9";
            string[] num = sb.Split(' ');
            for (int i = 0; i < num.Length; i++)
            {
                if ((int.Parse(num[i]) % 2 == 0))
                {
                    Oven.Add(int.Parse(num[i]));
                }
                else
                {
                    Even.Add(int.Parse(num[i]));
                }
            }
            Even.AddRange(Oven);
            foreach (var item in Even)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();