字典和列表 相互嵌套
🏳️🌈字典
字典的含义：
字典中key只能对应一个值不能对应多个值，线性结构。
实例化：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" }, };//直接创建实例化并赋值
常见方法：
添加：Dic.Add（key，value）给字典添加值
删除：Dic.Remove(key) 删除指定值
访问：Dictionary[key]表示key所对应的值
判断空：ContainsKey(key)判断key是否存在
遍历字典方法：
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： 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);//打印字典的值 } }
原文链接：https://blog.csdn.net/zhangay1998/article/details/118407717
