C#-笔记-集合数组全集-第三章

集合

ArrayList

集合：很多数据的一个集合，长度任意可变，类型随便。

			//创建了一个集合对象
            ArrayList list = new ArrayList();
            //集合：很多数据的一个集合
            //数组：长度不可变，类型单一
            //集合的好处：长度任意可变，类型随便
            list.Add(1);
            list.Add(3.14);
            list.Add("张三");
            list.Add(5000m);
            list.Add(true);
            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }

同时还有一种简便方法：如下

ArrayList list = new ArrayList
            {
                //集合：很多数据的一个集合
                //数组：长度不可变，类型单一
                //集合的好处：长度任意可变，类型随便
                1,
                3.14,
                "张三",
                5000m,
                true,
            };

如果把一个对象放进去，结果打印的是命名空间
结论：我们将一个对象输出到控制台 默认情况下打印的就是这个对象所在的类的命名空间。

list.Add(new int[] { 1,2,5,5,4,5,4,55445});
Persons p = new Persons();
list.Add(p);
结果是：
System.Int32[]
Test001.Persons

上边的添加输出的时候很难实现。

            for (int i = 0; i < list.Count; i++)
            {
                if (list[i] is Persons)//如果list[i]可以转换成Person类型就执行
                {
                    ((Persons)list[i]).SayHell();
                }
                else if (list[i] is int[])
                {
                    for (int j = 0; j < ((int[])list[i]).Length; j++)
                    {
                        Console.WriteLine(((int[])list[i])[j]);
                    }
                }
                else
                {
                    Console.WriteLine(list[i]);
                }

当我们向数组添加数据的时候用list.AddRange（）；

ArrayList list = new ArrayList();
            list.AddRange(new int[] { 1,5,5,5,55,787,5648,7});
            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }
 //list.Count表示最大值

list.Clear();//清空所有该语句上边的元素
list.Remove(“张三”);//清空指定元素
list.RemoveAt(0);//删除指定下标元素
list.RemoveRange(0,2);//删除指定下标范围元素
list.Reverse();//反转输出
list.Insert(1,“士大夫”);//在指定地插入指定数据list.InsertRange(0,new string[] {“ds”,“s”,“sad”,“asd” });//在指定位置插入一个数组
bool b = list.Contains(1);
Console.WriteLine(b);//b=true
判断是否包含一个字符返回一个bool类型的值

集合长度问题

每次集合中实际的元素个数（count）超过了可以包含的元素的个数（capcity）的时候，集合就会向内存中申请多开辟一倍的空间，来保证集合的长度一直够用。每次都是扩容两倍

ArrayList list = new ArrayList();
list.Add("张三");
Console.WriteLine(list.Count);
Console.WriteLine(list.Capacity);

以上就是内存的运行结果图。
ArrayList中的数据在进行算数运算的时候与数组计算的时候一样，只需要进行计算的时候加一步强转 sum += (int)list[i];因为原来数组里放的是object类型，其实也就是里氏转换的一种。object类强转int类，父类转子类

 ArrayList list = new ArrayList() { 1,4,5,47,5,4,5,4,54};
            int sum = 0;
            for (int i = 0; i < list.Count; i++)
            {
                sum += (int)list[i];
            }
            Console.WriteLine(sum);

HashTable 键值对集合

在键值对集合中，我们根据键去找值的。
键值对对象【键】=值；
注意：键值对集合当中，键必须是唯一的，而值是可以重复的。

添加数据是两种方法

ht.Add(false ,"错误的");
ht[10] = "李四";

ht[10] = “李四”;
这个比较强之前没有ht[10]就加进去，有的话就会把旧的ht[10]给覆盖了。
判断集合是否有某个key没有再加进去

if (!ht.ContainsKey("abc"))
            {
                ht.Add("abc","bca");
            }
ContainsKey("abc")判斷是否包含            

其他方法

ht.Clear();清除所有
ht.Remove(1);移除指定键值的键值对

foreach循环

var item in ht.Keys
每一个键 在 键值对键的集合下 遍历
var是根据值来推断类型，C#是一门强类型语言必须对每一个变量有一个明确的类型定义。

foreach (var item in ht.Keys)
            {
                Console.WriteLine("鍵是---{0}———值是—{1}",item,ht[item]);
            }

HashTable 使用范例，简繁转换
写两个字符串

private const string jian = "一二三四五六七八九十百千万亿元角分零整";
        private const string fan = "壹贰叁肆伍陆柒捌玖拾佰仟万亿圆角分零整";

Hashtable ht = new Hashtable();
            for (int i = 0; i < jian.Length; i++)//將简繁体字符串通过for放进去
            {
                ht.Add(jian[i],fan[i]);
            }
            Console.WriteLine("请随便输入");
            string input = Console.ReadLine();
            //遍历用户输入的字符串，将每一个都转换
            for (int i = 0; i < input.Length; i++)
            {
                if (ht.ContainsKey(input[i]))
                {
                    Console.WriteLine(ht[input[i]]);
                    //里边有就转换输出
                }
                else
                {
                    Console.WriteLine(input[i]);
                    //没有就原样输出
                }
            }

泛型集合

List泛型集合

//创建泛型集合对象
            List<int> list = new List<int>();
            list.Add(1);
            list.Add(2);
            list.AddRange(new int[] {1,2,3,55,4,5});
            list.AddRange(list);
            //list.Clear();
            //list.Remove(1);
            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }

ArrayList.那些功能都有

list.Clear();
list.Remove(1);

泛型可以转换成一个数组list.ToArray()

            int[] num = list.ToArray();
            for (int i = 0; i <num.Length; i++)
            {
                Console.WriteLine(num[i]);
            }

数组可以转换成一个泛型num.ToList()

List<int> list2 = num.ToList();
            for (int i = 0; i < list2.Count; i++)
            {
                Console.WriteLine(list2[i]);
            }

装箱，拆箱

装箱：就是将值类型转换为引用类型。
拆箱：就是将引用类型转换为值类型。
看两种类型是否发生了装箱或者拆箱，要看，这两种类型是否存在继承关系。

int n = 10;
object o = n;//值类型转化为引用类型//装箱
int nn = (int)o;//引用类型转值类型//拆箱

键值对集合

字典集合Dictionary<int, string>

			Dictionary<int, string> dic = new Dictionary<int, string>();
            dic.Add(1,"張三");
            dic.Add(2,"李四");
            foreach (KeyValuePair<int,string> kv in dic)//这的kv是键值对
            {
                Console.WriteLine("{0}-------{1}",kv.Key,kv.Value);
            }