02.C#集合
1.集合接口与集合类型
(1)集合的命名空间
大多数集合类都可以在System.Collections和System.Collections.Generic名称空间中找到。泛型集合位于System.Collections.Generic名称空间中；专用于特定类型的集合类位于System.Collections.Specialized名称空间中；线程安全的集合位于System.Collections.Concurrent名称空间中。
(2)集合接口介绍
1、IEnumerable与IEnumerator接口
其实IEnumerable接口是非常的简单，只包含一个抽象的方法GetEnumerator()，它返回一个可用于循环访问集合的IEnumerator对象。
public interface IEnumerable{ IEnumerator GetEnumerator();}
IEnumerator对象有什么呢？它是一个真正的集合访问器，没有它，就不能使用foreach语句遍历集合或数组，因为只有IEnumerator对象才能访问集合中的项。IEnumerator接口定义了：一个Current属性用来获取当前集合中的项；MoveNext方法将游标的内部位置向前移动；Reset方法将枚举数设置为其初始位置，该位置位于集合中第一个元素之前。
public interface IEnumerator{ object Current { get; } bool MoveNext(); void Reset();}
一个collection要支持foreach进行遍历，就必须实现IEnumerable,并以某种方式返回迭代器对象:IEnumerator。
2、集合和列表实现的接口表
IEnumerable<T> 如果foreach语句用于集合，就需要此接口。
ICollection<T> 此集合定义了Count属性、CopyTo、Add、Remove、Clear方法
IList<T> 可以通过位置访问几何元素
ISet<T> 此集合不允许有重复的元素
IDictionary<K,V> 含有键值对的集合
ILookup<K,V> 含有键值对的集合，但可以通过一个键包含多个值
IComparer<T> 集合元素比较器，用于集合元素的排序
IEqualityComparer<T> 用于字典集合的比较器
IProducerConsumerCollection<T> 线程安全的集合
2.集合的基本操作
(1)创建集合
使用默认的构造函数创建一个空集合，元素添加到集合之后，集合的容量就会扩大为4。当集合的容量被使用完，且还在向集合中添加元素时，集合的容量就会扩大成原来的2倍！可使用Capacity属性设置或访问集合的容量，使用Count属性访问集合的元素个数。也可使用TrimExcess方法调整集合容量，节省内存！
class Program{ static void Main(string[] args) { List<int> list = new List<int>();//List<int> list = new List<int>(3) for (int i = 0; i < 1025; i++) { if (list.Count == (list.Capacity)) { Console.WriteLine("容量使用量："+list.Count + "/" + list.Capacity); } list.Add(i); } Console.WriteLine("容量使用量：" + list.Count + "/" + list.Capacity); list.TrimExcess();//调整容量 Console.WriteLine("容量使用量：" + list.Count + "/" + list.Capacity); Console.Read(); }}
创建集合时可以为集合设置初始值，如下：
List<int> list = new List<int>() { 1,2,3,4,5,6,7,8,9,0};List<string> list = new List<int>() { "aa", "bb", "cc" };
(2)添加元素
为集合添加元素可使用Add方法，还可以使用AddRange方法一次添加多个元素，因为AddRange方法的参数是IEnumerable<T>类型的对象，所以可以添加数组到集合里。
class Program{ static void Main(string[] args) { List<string> list = new List<string>(); list.AddRange(new string[]{"aa","bb","cc"});//添加数组 list.AddRange(list);//添加集合 foreach (string s in list) { Console.WriteLine(s); } Console.Read(); }}
(3)插入元素
插入元素可以使用Insert方法，同样使用InsertRange方法插入多个元素，与AddRange方法类似。
class Program{ static void Main(string[] args) { List<string> list = new List<string>() { "aa", "bb", "ff" }; list.Insert(2, "cc");//插入元素 list.InsertRange(3, new string[] { "dd", "ee" });//插入集合 foreach (string s in list) { Console.WriteLine(s); } Console.Read(); }}
(4)访问元素
可以使用索引器访问集合中某个位置的元素，例如：
class Program{ static void Main(string[] args) { List<string> list = new List<string>() { "aa", "bb", "cc" }; Console.WriteLine(list[1]);//访问第1个位置上的元素，下标从0开始 Console.Read(); }}
集合的遍历，除了使用foreach外，还可以使用集合的Foreach方法，该方法的参数是一个Action<T>委托类型，可以使用Lambda表达式。例如：
class Program{ static void Main(string[] args) { List<string> list = new List<string>() { "aa", "bb", "cc" }; list.ForEach(temp => Console.WriteLine("元素：" + temp)); //也可使用： list.ForEach(Console.WriteLine); Console.Read(); }}
(5)删除元素
使用RemoveAt删除指定位置的元素，使用Remove删除指定的元素，使用RemoveRange删除指定位置范围的元素，使用Clear删除所有元素，使用RemoveAll选择删除的元素。
注意：RemoveAll方法的参数是一个Predicate<T>委托类型，使用方式如下：
class Program{ static void Main(string[] args) { List<string> list = new List<string>() { "12", "123", "1234", "12345" }; //删除长度小于4的元素 list.RemoveAll(x => { bool flag = x.Length < 4; return flag; }); list.ForEach(Console.WriteLine); Console.Read(); }}
(6)搜索元素
用于搜索的方法有：IndexOf、LastIndexOf、FindIndex、FindLastIndex、FindLast、Find、FindAll、Exists等方法。
IndexOf、LastIndexOf、FindIndex、FindLastIndex方法用于搜索元素的位置。
FindLast、Find、FindAll方法用于搜索满足条件的元素。
Exists用于判断集合是否存在某些元素。
参数可以使用Predicate<T>委托类型(Lambda表达式)的方法有：FindIndex、FindLastIndex、Find、FindLast、FindAll、Exists。例如：
class Program{ static void Main(string[] args) { List<string> list = new List<string>() { "12", "123", "1234", "12345" }; //搜索长度小于4的元素 list=list.FindAll(x => { bool flag = x.Length < 4; return flag; }); list.ForEach(Console.WriteLine); Console.Read(); }}
(7)元素排序
可以使用Sort方法对元素排序，也可以调用Reverse方法逆转集合顺序，Sort方法使用快速排序算法。Sort使用了几个重载的方法，可以传递的参数有泛型委托Comparison<T>和泛型接口IComparer<T>，例如：
class Program{ static void Main(string[] args) { List<string> list = new List<string>() { "12", "123", "1234", "12345" }; //按字符串长度排序 list.Sort((x, y) => { return y.Length - x.Length; }); list.ForEach(Console.WriteLine); Console.Read(); }}
(8)类型转换
使用ConvertAll<TOutput>方法可以把集合里的所有元素转换成另一种类型，ConvertAll<TOutput>使用了Converter委托，其定义如下：
public sealed delegate TOutput Converter<TInput, TOutput>(TInput from)
TInput是委托方法的参数类型，TOutput是委托方法的返回值类型。例如：
class Program{ static void Main(string[] args) { List<string> list = new List<string>() { "12", "123", "1234", "12345" }; //把字符串转换成数字(String->int) List<int> array = list.ConvertAll<int>(temp => Int32.Parse(temp)); array.ForEach(temp => Console.WriteLine((temp + 1))); Console.Read(); }}
(9)只读集合
集合的AsReadOnly方法可以返回一个ReadOnlyCollection<T>类型的集合；ReadOnlyCollection<T>是一个只读集合类型，除了不能使用修改集合的方法与属性，其它与集合一样。
(10)集合常用的扩展方法(常用)
集合的扩展方法很多，这里只举两个例子：Select与Where。例如：
Select：将序列中的每个元素投影到新表中。
class Program{ static void Main(string[] args) { List<int> list = new List<int>() {1,3,5,7,9}; IEnumerable<string> array = list.Select<int, string>(x => (x * x).ToString()); foreach(string s in array) { Console.WriteLine(s); } Console.Read(); }}
Where：基于谓词筛选值序列。
class Program{ static void Main(string[] args) { List<string> list = new List<string> { "1", "12", "123", "1234" }; //查询长度小于3的元素 IEnumerable<string> query = list.Where(temp => temp.Length < 3); foreach (string s in query) { Console.WriteLine(s); } Console.Read(); }}
3.常见集合的特性
(1)非泛型集合对应的泛型集合
非泛型集合类 对应的泛型集合类
ArrayList List<T>
HashTable DIctionary<T>
Queue Queue<T>
Stack Stack<T>
SortedList SortedList<T>
(2)队列(Queue<T>)
队列是其元素以先进先出的方式来处理的集合。该集合没有Add与Remove方法，其重要的方法如下：
Enqueue 在队列的尾端添加元素
Dequeue 在队列的头部读取并删除元素
Peek 只读取队列头部的元素
程序示例如：
class Program{ static void Main(string[] args) { Queue<string> queue = new Queue<string>(); for (int i = 1; i < 5; i++) { queue.Enqueue(i.ToString());//在尾部添加元素 } PrintQueue(queue);//输出元素 string s = queue.Dequeue();//读取并删除头部元素 Console.WriteLine("读取并删除头部元素:" + s); queue.Enqueue("5");//在尾部添加元素 s = queue.Peek();//读取头部元素 Console.WriteLine("读取头部元素:" + s); PrintQueue(queue);//输出元素 Console.Read(); } //输出元素 private static void PrintQueue(Queue<string> q) { IEnumerable<string> list = q.Where(t => true); foreach (string t in list) { Console.WriteLine(t); } }}
(3)栈(Stack<T>)
栈是一个后进先出的容器，其重要的方法如下：
Push 在栈顶压入一个元素入栈
Pop 从站顶读取并删除一个元素
Peek 只从站顶读取一个元素
程序示例如：
class Program{ static void Main(string[] args) { Stack<string> stack = new Stack<string>(); for (int i = 1; i < 5; i++) { stack.Push(i.ToString());//入栈 } PrintStack(stack);//输出元素 string s = stack.Pop();//读取并删除栈顶元素 Console.WriteLine("读取并删除栈顶元素:" + s); s = stack.Peek();//只读取栈顶元素 Console.WriteLine("只读取栈顶元素:" + s); PrintStack(stack);//输出元素 Console.Read(); } //输出元素 private static void PrintStack(Stack<string> s) { IEnumerable<string> list = s.Where(t => true); foreach (string t in list) { Console.WriteLine(t); } }}
(4)链表(LinkedList<T>)
LinkedList<T>是一个双向链表。链表的优点是，如果将元素插入列表的中间位置，使用链表就会非常快，只需要修改下一个元素的Next引用与上一个元素的Previous引用。链表不能在集合中只存储元素，必须要把元素存到LinkedListNode<T>类型的对象中，LinkedListNode<T>定义了属性：List、Next、Value、Previous。List属性返回与该节点相关的LinkedList<T>对象，Next、Previous用于遍历链表。
LinkedList<T>对象可以访问第一个和最后一个元素(Frist与Last)、在指定位置插入元素(AddAfter()、AddBefore()、AddFirst()、AddLast()方法)，删除指定位置的元素(ReMove()、ReMoveFirst()、RemoveLast()方法)，从链表的开头(Find())或结尾(FindLast())开始搜索元素。
程序示例如：
class Program{ static void Main(string[] args) { LinkedList<int> link = new LinkedList<int>(); LinkedListNode<int> node; for (int i = 0; i < 10; i++) { node = new LinkedListNode<int>(i); if (i % 2 == 0) { link.AddFirst(node);//从头部添加节点 } else { link.AddLast(node);//从尾部添加节点 } } PrintLink(link);//输出元素 Console.Read(); } //输出元素 private static void PrintLink(LinkedList<int> l) { IEnumerable<int> list = l.Where(t => true); foreach (int t in list) { Console.WriteLine(t); } }}
(5)有序列表(SortedList<K,V>)
SortedList<K,V>是基于键对集合进行排序的集合类，它只允许每个键只有一个对应值，如果需要每个键对应多个值可以使用Lookup<K,V>。可以使用foreach遍历该集合，枚举器返回的是KeyValuePair<K,V>类型的元素。除了使用Add方法添加元素，还可以使用索引器添加。例如：
class Program{ static void Main(string[] args) { SortedList<string, string> sort = new SortedList<string, string>(); sort.Add("K1", "V1");//Add方法添加元素 sort["K2"] = "V2";//索引器添加元素 PrintSorted(sort);//输出元素 Console.WriteLine("是否存在[K3]：" + sort.ContainsKey("K3")); string value = null; Console.WriteLine("是否存在[K2]：" + sort.TryGetValue("K2", out value)); Console.WriteLine("[K2]的值：" + value); Console.Read(); } //输出元素 private static void PrintSorted(SortedList<string, string> s) { IEnumerable<KeyValuePair<string, string>> list = s.Where(t => true); foreach (KeyValuePair<string, string> t in list) { Console.WriteLine(t.Key + " ---> " + t.Value); } }}
(6)字典
字典中键的类型必须重写Object类的GetHashCode()方法。只要字典类需要确定元素的位置，他就会调用GetHashCode()方法。除了实现GetHashCode()方法外，键类型还必须实现IEquatable<T>.Equals()方法，或重写Object类的Equals()方法。
因为不同的对象可能返回相同的散列码(GetHashCode方法返回值)，但是如果A.Equals(B)返回true，则A和B的散列码就必须相同。这似乎有点奇怪，但这非常重要，因为字典的性能取决于GetHashCode()方法实现的代码。
1、Dictionary<K,V>
Dictionary<K,V>类支持每个键关联一个值，与SortedList<K,V>很类似。
2、Lookup<K,V>
Lookup<K,V>类把键映射到一个值集上。创建Lookup<K,V>类对象必须调用ToLookup()扩展方法，该方法返回一个Lookup<K,V>对象。ToLookup()方法需要一个Func<T,K>类型的委托参数，Func<T,K>类型定义了键的选择器。
ToLookup()是一个奇妙的函数，用于对一个集合进行操作，创建一个1：n 的映射。 它可以方便的将数据分类成组，并生成一个字典供查询使用。例如：
class Program{ static void Main(string[] args) { List<string> list = new List<string>() { "1","12","123","1234","a","ab","abc"}; var lookup=list.ToLookup(x => x.Length);//根据元素的长度分组 foreach (var t in lookup) { List<string> temp=t.ToList<string>();//把一组数据转换成集合 temp.ForEach(x=>Console.Write(x+"、"));//输出集合 Console.WriteLine(); } Console.Read(); }}
3、SortedDictionary<K,V>
SortedDictionary<K,V>类是一个二叉搜索树，其中的元素根据键来排序，该键类型必须实现IComparable<T>接口。
SortedDictionary<K,V>与SortedList<K,V>的区别：
1.
SortedList<K,V>类使用的内存比SortedDictionary<K,V>少。
2.
SortedDictionary<K,V>类的元素的插入与删除比较快。
3.
在用于已排好序的集合，若不需要修改容量SortedList<K,V>会比较快。
区别的根本原因：SortedList<K,V>实现的是一个基于数组的集合，SortedDictionary<K,V>实现的是一个基于字典的集合。
(7)集(ISet<T>接口)
不包含重复元素的集合称为集，.NET Framework包含两个集(HashSet<T>和SortedSet<T>),它们都实现ISet<T>接口。HashSet<T>是不包含重复元素的无序列表，SortedSet<T>是不包含重复元素的有序列表。
4.可观察的集合(深入)
(1)ObservableCollection<T>类简介
ObservableCollection<T>类是为WPF定义的，这样UI就可以得知集合的变化，因为只要修改了ObservableCollection<T>类对象集合中的元素，它就会产生CollectionChanged 事件。
(2)使用示例
class Program{ static void Main(string[] args) { ObservableCollection<int> list = new ObservableCollection<int>(); list.CollectionChanged += ListCollectionChanged;//添加事件方法 list.Add(10);//产生事件 list.Add(20);//产生事件 list.Remove(10);//产生事件 Console.Read(); } //事件方法 private static void ListCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { Console.WriteLine("本次修改的方式：" + e.Action.ToString()); if (e.OldItems != null) { Console.WriteLine("本次修改的位置：" + e.OldStartingIndex); Console.WriteLine("本次修改的元素个数：" + e.OldItems.Count); } if (e.NewItems != null) { Console.WriteLine("本次修改的位置：" + e.NewStartingIndex); Console.WriteLine("本次修改的元素个数：" + e.NewItems.Count); } Console.WriteLine(); }}
5.位数组(深入)
(1)BitArray、BitVector32介绍
如果需要处理的数字有许多位，就可以使用BitArray类与BitVector32结构。它们的区别是：BitArray类可以重新设置大小，它可以包含很多位；BitVector32结构是基于栈的，因此比较快，但它只能包含32为，它们存在一个整数中。
(2)BitArray
BitArray类是一个引用类型，它包含一个int数组，其中32位使用一个新整数，其成员如下：
Count、Length Count、Length可得到数组的位数，Length可设置其数组的大小
Get、Set 使用Get、Set可访问数组中的位
SetAll SetAll()方法设置所有的位值
Not Not()方法对数组中所有的位求反
And、Or、Xor And()是与操作，Or()是或操作，Xor()是异或操作
程序示例：
class Program{ static void Main(string[] args) { BitArray barray = new BitArray(20); barray.SetAll(true);//对所有位赋值 PrintBitArray(barray);//输出 barray.Set(1, false); barray[2] = false; PrintBitArray(barray);//输出 Console.Read(); } //输出函数 private static void PrintBitArray(BitArray b) { foreach (bool bit in b) { Console.Write(bit ? 1 : 0); } Console.WriteLine(); }}
(3)BitVector32
BitVector32结构的效率更高，因为它是值类型！它常用成员如下：
Data Data属性把BitVector32结构返回成一个整数
索引器 访问BitVector32结构的值可以使用索引器
CreateMask 这是一个静态方法，为访问BitVector32结构中特定的类创建掩码
CreateSection 这是一个静态方法，用于创建32位中的几个片段
程序示例：
class Program{ static void Main(string[] args) { BitVector32 b32 = new BitVector32(); PrintBitVector32(b32);//输出位 int bit = BitVector32.CreateMask(); for (int i = 0; i < 4; i++) { b32[bit] = true; Console.WriteLine(bit); PrintBitVector32(b32);//输出位 b32[bit] = false; bit = BitVector32.CreateMask(bit); } Console.WriteLine(b32.Data);//输出数 Console.Read(); } //输出函数 private static void PrintBitVector32(BitVector32 b32) { for (int i = 0; i < 32; i++) { Console.Write(b32[i] ? 1 : 0); } Console.WriteLine(); }}
6.并发集合(.NET 4新增)
(1)ConcurrentQueue<T>
这个集合类用一种免锁定的算法实现，访问队列元素的方法有：TryDequeue、TryPeek和Enqueue。
(2)ConcurrentStack<T>
这个集合类定义了：Push()、PushRange、TryPeek、TryPop、TryPopRange方法。
(3)ConcurrentBag<T>
ConcurrentBag<T>表示对象的线程安全的无序集合。对于同一个线程值的添加和删除是非常快的，因为ConcurrentBag内部将数据按线程的标识而独立存储，所以一个线程从自己的数据中移除一个数据是非常快的，当然如果这个线程中没有数据，那么只能从其他线程中移除数据，此时会发生一些性能损耗从而确保线程安全！
(4)ConcurrentDictionary<K, V>
这是一个线程安全的键值集合，TyrAdd、TryGetValue、TryRemove、TryUpdate方法以非阻塞的方式访问元素。
(5)BlockingCollection<T>
这个集合在可以添加或提取元素元素之前，会阻塞线程并一直等待。可以使用Add、Take方法用来添加和删除元素，这些方法会阻塞当前线程，一直等到任务可以执行为止。
7.不同集合类的性能
集合 Add Insert Remove Item Sort Find
List O(1)或O(n) O(n) O(n) O(1) O(n log n)-O(n^2) --
Stack O(1)或O(n) n/a O(1) n/a n/a n/a
Queue O(1)或O(n) n/a O(1) n/a n/a n/a
HashSet O(1)或O(n) O(1)或O(n) O(1) n/a n/a n/a
SortedSet O(1)或O(n) O(1)或O(n) O(1) n/a n/a n/a
LinkedList O(1) O(1) O(1) n/a n/a O(n)
Dictionary O(1)或O(n) n/a O(1) O(1) n/a n/a
SortedDictionary O(log n) n/a O(log n) O(log n) n/a n/a
SortedList O(n)或O(log n) n/a O(n) O(n)或O(log n) n/a n/a
-------------------------------------------------------------------------------------------------------------------------------