【C#基础详解】（十三）集合

13.1 集合简介

1）集合与数组的区别：

集合：很多数据的一个集合

数组：长度不可变、类型单一

集合的好处：长度可以任意改变,类型任意，集合是以Object型存储元素，因为Object类是所有类的父类，所以可以存储所有类型的值。

2）非泛型集合创建：

使用ArrayList 集合时，必须引入这个命名空间：using System.Collections

ArrayList list = new ArrayList();

3）ArrayList的常用方法：

① ArrayList.Clear();清空所有元素

② ArrayList.Count;计算集合长度

扫描二维码关注公众号，回复： 15507405 查看本文章

        表示这个集合中实际包含的元素的个数： ArrayList.Count

        表示这个集合中可以包含的元素的个数： ArrayList.Capcity

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

③ ArrayList.Remove(元素);删除单个元素,写谁就删谁

④ ArrayList.RemoveAt(元素索引值);据索引删除元素

⑤ ArrayList.RemoveRange(0,3);根据索引去移除一定范围的元素

⑥ ArrayList.Sort();升序排列

⑦ ArrayList.Reverse();反转

⑧ ArrayList.Insert(索引位置,数据);在索引位置插入单个元素

⑨ ArrayList.InsertRange(5,new string[]{"张三","李四"});在指定的位置插入一个集合

        如： ArrayList.InsertRange(索引位置,数组);

⑩ ArrayList.Contains(元素)判断集合是否包含某个元素

 4）集合练习1：创建一个集合，里面添加一些数字，求平均值与和

ArrayList list = new ArrayList();
list.Add(1);
list.Add(2);
list.Add(3);
list.Add(4);
int sum = 0;
for (int i = 0; i < list.Count; i++)
{
    sum += (int)list[i];//强转为int类型
}
Console.WriteLine("和是{0}，平均值是{1}", sum, sum / list.Count);
Console.ReadKey();

13.2 Hashtable（哈希表）键值对集合

1）哈希表简介：

在键值对集合中,是根据键去找值的

例如：通过字典找字

sun-->孙,拼音是“键”,找出来的字是“值”

2）哈希表的声明：

使用Hashtable时，必须引入这个命名空间：using System.Collections

Hashtable ht = new Hashtable();

3）向哈希表添加元素：

ht.Add("key", "value");

哈希表的每个元素都包含2个值，一个是键，另一个是值

注意：键值对集合当中,键必须是唯一的,而值是可以重复的

4）什么情况下使用哈希表：

 某些数据会被高频率查询；数据量大；查询字段包含字符串类型；数据类型不唯一代码段

5）哈希表的常用方法：

Hashtable ht = new Hashtable();

//添加一个keyvalue键值对

ht.Add(Key, value);

//移除某个keyvalue键值对

ht.Remove(key);

//移除所有元素

ht.Clear();

//判断是否包含特定键key

ht.Contains(key);

 6）哈希表遍历的方式：

Hashtable ht = new Hashtable();//创建一个Hashtable实例
ht.Add(1, "帝都");//添加key-value键值对
ht.Add(2, "魔都");
ht.Add(3, "省会");
ht.Add(4, "特区");
foreach (int item in ht.Keys)//value
{
    Console.WriteLine($"键是={item}=值是{ht[item]}");
}
Console.ReadKey();

7）哈希表练习：简繁转换

private const String Jian = "阿斯顿发广告";
private const String Fan = "阿斯頓發廣告";
static void Main(string[] args)
{
    Hashtable ht = new Hashtable();
    for (int i = 0; i < Jian.Length; i++)
    {
        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.Write(ht[input[i]]);
        }
        else
        {
            Console.Write(input[i]);
        }
    }
    Console.ReadKey();
}

13.3 泛型集合--List<T>

1）泛型集合简介：

泛型集合是只能存储固定类型的对象的一种集合。

必须引入对应的命名空间:System.Collections.Generic

        List< T >是一个C#内置的一个类，是类我们就可以实例化出对象。List< T >本质和数组是一样的。因为List< T >这个类的内部其实是维护了一个数组。

        但是List< T >比数组灵活，这个类封装了很多方便我们操作这个内部数组的各种方法，我们可以方便的对数据进行增加，删除，修改等操作，且List< T >的长度是可以动态改变的，在实例化List< T >类型对象时，不需要指定长度。

2）泛型集合的基本使用:

增加数据：集合名.Add (Value) 往集合中添加数据

查询数据：集合名[索引] 取出指定索引位置的数据

 删除数据：集合名.RemoveAt(索引) 删除指定索引位置的数据

 修改数据：集合名[索引] = 新值; 给指定索引的的数据重新赋值例如：List<int> num = new List<int>();//添加数据num.Add(5);

num.Add(6);

num.Add(7);

//读取数据

for (int i = 0; i < num.Count; i++)

{

      Console.WriteLine(num[i]);

}

//删除集合第二个数（索引)

num.RemoveAt(2);

//通过索引修改数据 

num[1] = 100;

3）泛型集合转数组：ToArray()

ToArray( )方法可以使泛型集合转数组

注意: 最后转成的数组类型取决于泛型集合的类型。

例如：

static void Main(string[] args)
{
    // 创建一个整数泛型集合
    List<int> num = new List<int>();
    num.AddRange(new int[]{ 1, 2, 3, 4 });
    int[] res = num.ToArray();
    Console.ReadKey();
}

4）数组转泛型集合：ToList()

static void Main(string[] args)
{
    string[] str = new string[]{"1", "2", "3"};
    List<string> res =str.ToList();
    Console.WriteLine(res.GetType());
    Console.ReadKey();
}

输出结果：System.Collections.Generic.List`1[System.String]

5）泛型集合练习：向泛型集合添加元素

static void Main(string[] args)
{
    // 创建一个整数泛型集合
    List<int> num = new List<int>();
    num.Add(1);
    num.AddRange(new int[]{ 1, 2, 3, 4 });
    for (int i = 0; i < num.Count; i ++)
    {
        Console.WriteLine(num[i]); //输出结果1 1 2 3 4
    }
    Console.ReadKey();
}

13.4 泛型键对值集合--Dictionary<K,V>

字典集合（Dictionary<K,V>）本身像它名字那样通俗易懂，也就是“根据…查找出…”。其存储数据的方式与哈希表相似，通过键/值来保存元素，并具有泛型的全部特征，编译时检查类型约束，读取时无需类型转换。

1）语法：

Dictionary<键的类型,值的类型> dic = new Dictionary<键的类型,值的类型>();

2）注意：

• 从一组键（Key）到一组值（Value）的映射，每一个添加项都是由一个值及其相关连的键组成
• 任何键都必须是唯一的
• 键不能为空引用null，若值为引用类型，则可以为空值
• Key和Value可以是任何类型（string，int，class 等）
• dictionary[键] = 值;的方式既可以赋新值可以修改原来已键有的值，类似于数组索引器的使用, 所以可以使用之前已使用过的键。但是Add方法不可以添加已有键的值。
• Dictionary<int, string> dictionary = new Dictionary<int,  string>();

3）两种赋值方式：

方式一：Add 方法赋值

dictionary.Add(1, "98分");

dictionary.Add(2, "92分");  

dictionary.Add(3, "89分");

dictionary.Add(1, "88分"); //系统会报错=

方式二：索引器赋值  

dictionary[1] = "88分"; //系统不会报错

dictionary[4]  = "99分";

4）对象初始化器：

Dictionary<string, string> dictionary = new Dictionary<string, string>()

{

{"A","aa" },

{"B","BB" },

{"C","CC" }

};

 5）取值：

Dictionary<string, string> dictionary = new Dictionary<string, string>(){
{"A","aa" },
{"B","bb" },
{"C","cc" }
};
//方式一：索引取值  
string value1 = dictionary["A"];
Console.WriteLine(value1);
//方式二：foreach遍历取值  
foreach (KeyValuePair<string, string> item in dictionary)
{
    string key = item.Key;
    Console.Write(key);
    string value = item.Value;
    Console.Write(value);
}
Console.ReadKey();

输出结果：

aaAaaBbbCcc

6）字典练习：

static void Main(string[] args)
{
    //1.声明字典集合对象，并指定键和值的类型
    Dictionary<string, int> dic = new Dictionary<string, int>();
    //2.如何向集合中添加数据
    dic.Add("aa", 12);//向字典集合中添加数据的第一种方式
    dic.Add("bb", 15);
    dic.Add("cc", 21);
    dic["dd"] = 17;//向字典集合中添加数据的第二种方式
    dic["cc"] = 29;//如果字典集合已经有键为"cc"的数据，则覆盖那个键对应的值，否则生成新的一组数据
    //3.如何从集合中取数据
    int value = dic["bb"];//可以根据键来获取到字典集合的值
    //可以直接用foreach循环遍历出集合中的数据，这里必须使用KeyValuePair，而不是var
    foreach (KeyValuePair<string, int> item in dic)
    {
        Console.WriteLine("键是{0}，值是{1}", item.Key, item.Value);
    }
    Console.ReadKey();
}

输出结果：

键是aa，值是12

键是bb，值是15

键是cc，值是29

键是dd，值是17

13.5 装箱和拆箱

装箱就是将比如int类型或者string等不同的对象通过强转为object对象。例如：

int i = 123;

object o = 1;

拆箱就是将object对象通过显示转换赋给int类型的变量

object o = 123;

int i = (int)o;

注意：

装箱与拆箱的过程会产生较多的性能损耗。

正是因为ArrayList存在不安全类型与装箱拆箱的缺点，所以在C#2.0后出现了泛型的概念。

13.6 集合的练习

1）练习1：将一个数组中的奇数放在一个集合中，再将偶数放到另一个集合中，最终将两个集合合并为一个集合，并且奇数显示在左边，偶数在右边。

int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
ArrayList list = new ArrayList();
ArrayList ouList = new ArrayList();
ArrayList jiList = new ArrayList();
for (int i = 0; i < nums.Length; i++)
{
    if (nums[i] % 2 == 0)
    {
        ouList.Add(nums[i]);
    }
    else
    {
        jiList.Add(nums[i]);
    }
}
jiList.AddRange(ouList);
foreach (var item in jiList)
{
    Console.Write(item);
}
Console.ReadKey();

输出结果：135792468

2）练习2：提示用户输入一个字符串，通过foreach循环将用户输入的字符串赋值给一个字符数组。

Console.WriteLine("请输入一个字符串：");
string input = Console.ReadLine();
char[] chs = new char[input.Length];
//要依次访问到string中的每个元素需要下标指引
int i = 0;
foreach (var item in input)   //item就是string中每个字符的项
{
    chs[i] = item;
    i++;
}	
foreach (var item in chs)
{
    Console.Write(item + " ");
}
Console.ReadKey();

3）练习3：键值对集合是根据键去找值，查找每个字符出现的次数

string str = "Welcome to China";
Dictionary<char, int> dic = new Dictionary<char, int>();
for (int i = 0; i < str.Length; i++)
{
    if (str[i] == ' ')
    {
        continue;
    }	
    //如果dic已经包含了当前循环的这个键
    if (dic.ContainsKey(str[i]))
    {
        dic[str[i]]++;
    }
    else //这个字符在集合当中是第一次出现
    {
        dic[str[i]] = 1;
    }
}
foreach (KeyValuePair<char, int> kv in dic)
{
    Console.WriteLine("字母{0}出现了{1}次", kv.Key, kv.Value);
}
Console.ReadKey();

输出结果：

字母W出现了1次

字母e出现了2次

字母l出现了1次

字母c出现了1次

字母o出现了2次

字母m出现了1次

字母t出现了1次

字母C出现了1次

字母h出现了1次

字母i出现了1次

字母n出现了1次

字母a出现了1次