C#中各种泛型集合的使用方法总结

本篇体验除Queue<T>和Stack<T>之外的其它泛型集合。
SortedList<TKey, TValue>

SortedList<TKey, TValue>和List<T>比较相似，不同的地方在于SortedList集合元素是排过序的，往SortedList集合添加元素的时候需要添加键值对数据。在添加集合元素的时候，首先采用"二分查找算法"找到合适的位置，然后元素被放到该位置，该位置后面所有的集合元素整体后退一位。

1.         static void Main(string[] args)
2.         {
3.             var mySotedList = new SortedList<int, string>();
4.             mySotedList.Add(1, "张三");
5.             mySotedList.Add(2,"李四");
6.             mySotedList.Add(3,"赵六");
7.             mySotedList.Add(4,"王九");
8.             //判断是否包含某个键
9.             mySotedList.ContainsKey(1);
10.             //判断是否包含某个值
11.             mySotedList.ContainsValue("张三");
12.             //获取某个键的索引
13.             int keyIndex = mySotedList.IndexOfKey(2);
14.             //获取某个值的索引
15.             int valIndex = mySotedList.IndexOfValue("李四");
16.             //根据键删除
17.             mySotedList.Remove(3);
18.             //根据索引删除
19.             mySotedList.RemoveAt(1);
20.             //根据键查找元素
21.             string myVal = mySotedList[3];
22.             //根据索引查找元素
23.             string myVal1 = mySotedList.Values[1];
24.             //根据索引查找键
25.             int myKey = mySotedList.Keys[3];
26.             //获取某个元素而不抛异常
27.             string myWantVal;
28.             if (mySotedList.TryGetValue(2, out myWantVal))
29.             {
31.             }
32.             //遍历键
33.             foreach (int key in mySotedList.Keys)
34.             {
36.             }
37.             //遍历值
38.             foreach (string str in mySotedList.Values)
39.             {
41.             }
42.         }

复制代码

使用SortedList<TKey, TValue>相对不足的地方在于：当插入数据的时候，是通过"二分查找算法"确定插入位置的，开销相对昂贵；但，由于SortedList<TKey, TValue>集合元素是排过序的，这又让查找变得方便。
如果需要对一个集合进行经常性的查找，而向集合插入数据相对不多，就可以考虑使用SortedList<TKey, TValue>。   
Dictionary<TKey,TValue>

Dictionary<TKey,TValue>把存储的数据放在了一个HashTable中，每个集合元素的键必须是唯一的，且集合元素未经排序。
与SortedList<TKey, TValue>相似的地方在于也是以键值对的形式添加集合元素的，不同的地方在于：插入数据的效率Dictionary<TKey,TValue>比SortedList<TKey, TValue>要高。

1.             var myDictionary = new Dictionary<int, string>();
2.             myDictionary.Add(1, "darren");
3.             myDictionary.Add(2, "jack");
4.             myDictionary.Add(3, "sunny");
5.             //根据键判断是否存在
6.             myDictionary.ContainsKey(1);
7.             //根据值判断是否存在
8.             myDictionary.ContainsValue("darren");
9.             //根据键删除
10.             myDictionary.Remove(3);
11.             //根据键查找集合元素
12.             string myVal = myDictionary[2];
13.             //根据键查找元素不抛异常
14.             string myVal1;
15.             if (myDictionary.TryGetValue(2, out myVal1))
16.             {
18.             }
19.             //遍历键
20.             foreach (int key in myDictionary.Keys)
21.             {
23.             }
24.             //遍历值
25.             foreach (string value in myDictionary.Values)
26.             {
28.             }

复制代码

SortedDictionary<TKey,TValue>

SortedDictionary<TKey,TValue>与SortedList<TKey, TValue>最大的不同在于：SortedDictionary<TKey,TValue>不允许通过索引获取集合元素，其内部维护着一个"红黑树"，所以，当执行插入操作的时候，相比SortedList<TKey, TValue>，SortedDictionary<TKey,TValue>有更好的执行效率，当然也占用了更多的内存。

1.            var mySortedDictionary = new SortedDictionary<int, string>();
2.             mySortedDictionary.Add(1,"one");
3.             mySortedDictionary.Add(2,"two");
4.             mySortedDictionary.Add(3,"three");
5.             //判断是否包含某个键
6.             mySortedDictionary.ContainsKey(2);
7.             //判断是否包含某个值
8.             mySortedDictionary.ContainsValue("two");
9.             //根据键移除某个元素
10.             mySortedDictionary.Remove(2);
11.             //根据键查找某个元素
12.             string myVal = mySortedDictionary[1];
13.             //根据键查找元素，不抛异常
14.             string myVal1;
15.             if (mySortedDictionary.TryGetValue(1, out myVal1))
16.             {
18.             }
19.             //遍历所有键
20.             foreach (int key in mySortedDictionary.Keys)
21.             {
23.             }
24.             //遍历所有值
25.             foreach (string val in mySortedDictionary.Values)
26.             {
28.             }

复制代码

LinkedList<T>

每个集合元素都有属性指向前一个和后一个节点。第一个的前一个节点是最后一个节点，后一个节点是第二个节点。最后一个节点的前一个节点是倒数第二个节点，后一个节点是第一个节点。

1.            var myLinkedList = new LinkedList<string>();
2.             //创建第一个节点
3.             myLinkedList.AddFirst("one");
4.             //创建最后一个节点
5.            var lastNode = myLinkedList.AddLast("three");
6.             //在最后一个节点前添加一个节点
7.             myLinkedList.AddBefore(lastNode, "two");
8.             //在当前最后一个节点后面添加一个节点
9.             myLinkedList.AddAfter(lastNode, "four");
10.             //遍历节点值
11.             foreach (string value in myLinkedList)
12.             {
14.             }
15.             //根据值查找节点
16.             //找到符合条件的第一个节点
17.             var myNode = myLinkedList.Find("two");
18.             //根据值查找节点
19.             //找到符合条件的最后一个节点
20.             var myNode1 = myLinkedList.FindLast("one");
21.             //获取第一个节点
22.             var firstNode = myLinkedList.First;
23.             //获取最后一个节点
24.             var lastNode1 = myLinkedList.Last;
25.             //根据值产生节点
26.             myLinkedList.Remove("one");
27.             //删除第一个节点
28.             myLinkedList.RemoveFirst();
29.             //删除最后一个节点
30.             myLinkedList.RemoveLast();
31.             //清空所有节点
32.             myLinkedList.Clear();

复制代码

如果对一个集合有很多的插入操作，或者插入批量集合元素，可以考虑使用LinkedList<T>。
SortedSet<T>

SortedSet<T>的内部其实是SortedDictionary类型，但是没有键，只有值。SortedSet代表一个抽象的数据集，数据集中的元素值必须是唯一的，未经过排序的。
如果需要对一组数据进行合并等操作，可以考虑使用SortedSet<T>。

1.             var sortedSet1 = new SortedSet<string>();
2.             sortedSet1.Add("one");
3.             sortedSet1.Add("two");
4.             sortedSet1.Add("three");
5.             var sortedSet2 = new SortedSet<string>();
6.             sortedSet2.Add("two");
7.             sortedSet2.Add("four");
8.             //判断某个值是否存在
9.             sortedSet1.Contains("one");
10.             //合并数据集，取出重复项
11.             sortedSet1.ExceptWith(sortedSet2);
12.             //判断一个数据集是否是另一个数据集的自己
13.             sortedSet1.IsSubsetOf(sortedSet2);
14.             //判断一个i额数据集是否包含另一个数据集的所有元素
15.             sortedSet1.IsSubsetOf(sortedSet2);
16.             //判断两个数据集是否有交集
17.             sortedSet1.Overlaps(sortedSet2);
18.             //根据值删除某个元素
19.             sortedSet1.Remove("two");
20.             //判断两个数据集是否相等
21.             sortedSet1.SetEquals(sortedSet2);
22.             //只包含在一个数据集中的元素，这些元素不包含在另一个数据集
23.             sortedSet1.SymmetricExceptWith(sortedSet2);
24.             //取两个数据集的并集
25.             sortedSet1.UnionWith(sortedSet2);
26.             //获取包含某些元素的数据集
27.             SortedSet<string> result = sortedSet1.GetViewBetween("one", "two");
28.             //遍历数据集
29.             foreach (string val in sortedSet1)
30.             {
32.             }
33.             //清空数据集
34.             sortedSet1.Clear();

复制代码

HashSet<T>

HashSet和SortedSet都实现了ISet接口。使用SortedSet的前提是：需要根据多个元素值作为查找条件；数据不能被哈希。其余情况应考虑使用HashSet。

1.             var hashSet1 = new HashSet<string>();
2.             hashSet1.Add("one");
3.             hashSet1.Add("two");
4.             hashSet1.Add("three");
5.             var hashSet2 = new HashSet<string>();
6.             hashSet2.Add("two");
7.             hashSet2.Add("four");
8.             //判断是否包含某个值
9.             hashSet1.Contains("four");
10.             //去掉一个数据集中与另一个数据集重复的项
11.             hashSet1.ExceptWith(hashSet2);
12.             //保留一个数据集中与另一个数据集相同的项
13.             hashSet1.IntersectWith(hashSet2);
14.             //判断一个数据集是否是另一个数据集的子集
15.             hashSet1.IsSubsetOf(hashSet2);
16.             //判断一个数据集是否包含另一个数据集的所有元素
17.             hashSet1.IsSupersetOf(hashSet2);
18.             //判断两个数据集是否有重复的元素
19.             hashSet1.Overlaps(hashSet2);
20.             //根据值删除某个元素
21.             hashSet1.Remove("one");
22.             //判断两个数据集是否相等
23.             hashSet1.SetEquals(hashSet2);
24.             //合并两个数据集
25.             hashSet1.UnionWith(hashSet1);
26.             //查找只包含在一个数据集中，却不包含在另一个数据集的元素
27.             hashSet1.SymmetricExceptWith(hashSet2);
28.             //遍历数据集
29.             foreach (string value in hashSet1)
30.             {
32.             }
33.             //清空数据集
34.             hashSet1.Clear();

复制代码

这几天体验了各个泛型集合的用法。总结如下：
Stack<T>先进后出, 在这里。
Queue<T>先进先出，在这里。
SortedList<TKey, TValue>，插入数据不是很频繁，且经常需要查找。
Dictionary<TKey,TValue>，经常插入数据，不排序，键值对。
SortedDictionary<TKey,TValue>，经常插入数据，排序，键值对。
LinkedList<T>，双向链表，插入很随意。
SortedSet<T>，数据集，根据多个元素值作为查找条件；数据不能被哈希。
HashSet<T>，数据集，大多数情况下使用HashSet处理数据集操作。
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对中国红客联盟的支持。如果你想了解更多相关内容请查看下面相关链接