⭐️C# 零基础到进阶⭐️| 字典和列表 相互嵌套使用 的终极总结！

字典和列表 相互嵌套

• ​​前言​​

• ​​字典​​

• • 
    
• ​​字典嵌套字典​​
• ​​字典嵌套列表​​
  • 
    

• ​​列表​​

• • 
    
• ​​列表嵌套列表​​
• ​​列表嵌套字典​​
  • 
    

• ​​总结​​
  • 
    

前言

• • 
    
• 最近因为工作需求需要用到列表和字典嵌套使用来达成效果
• 好久不用都有点忘记咋用了，所以就去搜了搜
• 发现是有文章介绍嵌套使用，但是很零散、不齐全
• 然后我就写了一篇，自己写代码实例尝试了一下，差不多将字典和列表相互嵌套的几种方法都写出来了
• 一起来搞懂字典和列表的相互嵌套具体怎样使用吧！
  • 
    

字典

字典的含义：

字典中key只能对应一个值不能对应多个值，线性结构。

1. 实例化：Dictionary<键key,值value> 名字dic=new Dictionary<键key,值value>（）;

Dictionary<string,string> Dic=new Dictionary<string,string>();//普通创建实例化

Dictionary<string,string> Dic1 = new Dictionary<string, string> { { "a", "1" }, { "b", "2" }, };//直接创建实例化并赋值

2. 2. 
      
3. 常见方法：
   添加：Dic.Add（key，value）给字典添加值
   删除：Dic.Remove(key) 删除指定值
   访问：Dictionary[key]表示key所对应的值
   判断空：ContainsKey(key)判断key是否存在
4. 遍历字典方法：
   2. 
      

Dictionary<string, string> d = new Dictionary<string, string>();

        foreach (var item in d)
        {
            Console.WriteLine(item.Key+item.Value);//遍历打印链表中的值   
        }

字典嵌套字典

• • 
    
• 字典嵌套字典，在创建字典的时候，将里面一层再写一个字典，就完成字典嵌套了，里面的字典就相当于外层字典的Value值
• 在实例化的时候只是实例化了外层的字典，在给外层字典赋值的时候，需要将内层嵌套的字典再进行实例化
• 然后拿到外层字典的key之后，再给内层的字典赋值Key和Value
• 遍历的时候，双层循环，先遍历外层字典，然后在遍历外层字典的Value(也就是内层字典)
  • 
    

Dictionary<string, Dictionary<string, string>> Dic1;

        Dic1 = new Dictionary<string, Dictionary<string, string>>();
        //方法一
        Dic1.Add("key",new Dictionary<string, string>());//对应的内嵌字典需实例化
        Dic1["key"].Add("key", "value");//添加外层值

        //方法二
        Dic1["key"] = new Dictionary<string, string>();//给外层的某个值赋值字典值
        Dic1["key"].Add("key1", "value");//外层字典的key，赋值嵌套的字典值

        Console.WriteLine(Dic1["key"]["key1"]);//读取嵌套字典里的某个值
        //打印结果：value

        //遍历嵌套字典
        foreach (var item in Dic1)
        {
            Debug.Log("外层字典：" + item);//遍历打印外层字典中的值
            foreach (var item1 in item.Value)
            {
                Console.WriteLine("内层字典：" + item1);//遍历外层字典的Value，来打印内层字典中的值  
            }
        }
        //打印结果：
        //外层字典：keySystem.Collections.Generic.Dictionary`2[System.String,System.String]
        //内层字典：[key1, value]

字典嵌套列表

• • 
    
• 字典嵌套列表跟上面的嵌套字典是一个道理
• 也是把外层字典的Value换成列表
• 然后实例化的时候也是如此，先实例化外层字典，在给字典赋值的时候在实例化列表元素
• 在遍历的时候与字典嵌套字典一模一样
  • 
    

Dictionary<string, List<string>> Dic1;

        Dic1 = new Dictionary<string, List<string>>();

        Dic1.Add("key1", new List<string> { "第一个", "第二个", "第三个" });//给字典和列表赋值
        Dic1.Add("key2", new List<string> { "第四个", "第五个", "第六个" });//给字典和列表赋值

        foreach (var item in Dic1)
        {
            Console.WriteLine("字典：" + item.Key + item.Value);//遍历打印字典中的值
            foreach (var item1 in item.Value)
            {

                Console.WriteLine("列表："+item1);//遍历打印链表中的值   
            }
        }

列表

当我们有很多类型一样的数据时，可以使用数组来进行存储并管理，但是这样的缺点是数组的大小是提前给定的、是固定的。

• 如果我们有许多类型一样但数量不定的数据，我们可以使用集合类来进行管理——例如列表List。我们可以使用列表List很方便的添加数据，删除数据以及其他的一些数据操作。

1. 实例化的三种方法

方法1：
List<int> list = new List<int>();//创建了一个空列表
方法2：
var list = new List<int>();//创建了一个空列表
方法3：创建并初始化赋值
var list = new List<int> {1,2,3};

两种遍历列表的方法
```csharp
List<int> scoreList = new List<int>（）;
            //第一种：依次获得list中的每一个元素，赋值给temp，并执行循环体
            foreach (string s in list)
            {
                Console.WriteLine(s);//遍历打印链表中的值
                //打印结果：链表2 链表3
            }

            //第二种：遍历所有的索引，通过索引访问列表中的元素
             for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);//遍历打印链表的值
            }

使用方法
添加：list.Add(key)给字典添加值
删除：list.Remove(key) 删除指定值
访问：list[key]表示key所对应的值

列表的小知识
① 列表内部数据其实是使用数组进行存储的。一个空的列表内部会有一个长度为0的数组。当对列表中添加元素时，列表的容量会扩大到4，如果添加第五个元素时，列表的大小就会重新扩大到8，以此类推。一次2倍的形式增加。
② 当列表的容量发生改变时，它会创建一个新的数组，使用Array.Copy()方法将就数组中的元素复制到新数组中。为了节省时间，如果事先知道所要存储的元素的个数，就可以利用列表的构造函数指定列表的容量大小

例如：

List<int> intList = new List<int> (10);
//创建了一个容量为10的列表
//当容量不够时，每次都会按照原来的2倍进行容量的扩充

我们可以通过Capacity属性来获取和设置容量大小。

intList.Capacity = 100;

注意容量和列表中的元素个数的区别。

容量是列表中用于存储数据的数组的长度，通过Capacity进行获取。

而列表中的元素则是我们添加进去的、需要管理的数据，通过Count进行获取。

列表嵌套列表

• • 
    
• 列表嵌套列表就相对好理解了，毕竟列表我们在添加的时候，只需要添加一个属性值
• 嵌套使用的话就是List<List>就好了，然后添加的时候把内层的列表当做一个值添加给外层列表
• 遍历的时候也是双层循环访问即可
  • 
    

//创建嵌套列表和普通列表
        List<List<string>> list1 = new List<List<string>>();
        List<string> list2 = new List<string>();
        List<string> list3 = new List<string>();
        //普通链表赋值
        list2.Add("链表2");
        list3.Add("链表3");
        //嵌套链表赋值
        list1.Add(list2);
        list1.Add(list3);
        //遍历嵌套链表
        foreach (List<string> i in list1)
        {
            foreach (string s in i)
            {
                Console.WriteLine(s);//打印链表的值
                //打印结果：链表2 链表3
            }
        }

列表嵌套字典

• • 
    
• 列表嵌套字典，就是把字典当做外层列表的一个属性值
• 然后将字典通过Add的方式添加给列表
• 遍历的时候，也是先遍历列表，然后在遍历字典就可以拿到数据了
  • 
    

List<Dictionary<string, string>> list1;//创建嵌套字典的列表
        Dictionary<string, string> d;//创建字典

        d = new Dictionary<string, string>();//实例化字典
        list1 = new List<Dictionary<string, string>>();//实例化列表

        list1.Add(d);//将字典添加进列表，这种方式

        d.Add("key", "value");//直接给字典赋值

        list1[1].Add("key", "value");//也可以通过列表给字典赋值

        //遍历嵌套字典
        foreach (var item in list1)
        {
            foreach (var item1 in item)
            {
                Console.WriteLine(item1);//打印字典的值
            }
        }

总结

字典和列表 相互嵌套使用 的几种方式，包括实例讲解，应该没有被绕晕吧，这只是介绍了双层嵌套使用

更多层的嵌套使用方法类似，就一直套用就好了，遍历的时候多次循环使用就好啦！

今天你学废了吗！