C#高级编程（第9版） 第10章 集合 笔记

话说 虽然敲过好多代码， 但除了C++，一直没正眼瞧过其它语言。（没办法 谁叫C++既有oop又能自由控制内存呢）

今天 看公司老项目的src，c#的，linq+Dictionary的用法有感。所以找来C#的资料 就学了一下，妈的 变天儿了。

以后不能再用C++编写思路，囫囵着过日子了。

------------------------------------------------------------------ 我是分割线 -----------------------------------------------------------------------

以下 学习笔记

列表List<T>、队列、栈、链表、字典和集；

位数组 和 并发集合 【多线程环境使用】

 

集合借口和类型

大多数集合类在System.Collections 和 System.Collections.Generic命名空间中。

泛型集合 ==> System.Collections.Generic

专用于特定类型的集合类 ==> System.Collections.Concurrent

不可变的集合类 ==> System.Collections.Immutable

 

列表

.NET Framework为动态列表提供了泛型类 List<T>。

这个类实现了IList、ICollection、IEnumerable、IList<T>、ICollection<T>和IEnumerable<T>接口。

 

ArrayList是一个非泛型列表，它可以将任意Object类型作为其元素。

 

使用默认的构造函数创建一个空列表。元素添加到列表中后，列表的容量就会扩大为可容纳4个元素。如果添加了第5个元素，列表的大小就成新设置为包含8个元素，如果8个元素还不够，列表的大小就重新设置为包含16个元素。每次都会将列表的容量重新设置为原来的2倍。

如果列表的内容改变了，整个集合就要重新分配到一个新的内存块中。即创建一个新的数组，大小是原来的2倍。

 

创建指定元素个数的列表

List<int> intList = new List<int>(10);

 

可以通过索引访问的集合类有 ArrayList、StringCollection 和 List<T>

 

ForEach()方法遍历集合中的每一项，调用作为每一项的参数传递的方法。

public delegate void Action<T> (T obj);
public void ActionHandler (Racer obj);
racers.ForEach( Console.WriteLine );
racers.ForEach( r => Console.WriteLine（"{0:A}", r）; //lambda表达式

删除元素

删除元素时，可以利用索引，也可以传递要删除的元素。

按索引删除比较快，因为必须在集合中搜索要删除的元素。Remove()方法现在集合中搜索，用IndexOf()方法获取元素的索引，在使用该索引删除元素。IndexOf()方法先检查元素类型是否实现了IEquatable<T>接口。如果是就调用这个接口的Equals()方法，确定集合中的元素是否等于传递给Equals()方法的元素。如果没有实现这个接口，就使用Object类的Equals()方法比较这些元素。Object类中的Equals()方法的默认实现代码对值类型进行比较，对引用类型只比较其引用。

重写IEquatable<T>接口或Object.Equals()方法可以根据列表元素对象的特定属性进行删除列表元素。

第7章 介绍如何重写Equals()方法

 

搜索

有不同的方式在集合中搜索元素。可以获得要查找的元素的引用，或者搜索元素本身。

方法有：

IndexOf()
LastIndexOf()
FindIndex()
FindLastIndex()
Find()
FindLast()
检查元素是否存在：List<T>.Exists()方法;

IndexOf()可以指定不需要搜索整个集合，需要指定开始索引以及需要迭代的元素个数

FindIndex()可以搜索有某个特性的元素

public int FindIndex(Predicate<T> match); //Predicate<T>类型是一个委托，该委托返回一个bool值

int index = racers.FindIndex( r => r.Country == "FinLand");

 

FindIndex()方法返回所查找元素的索引。Find()方法除了获得索引之外，还可以直接获得集合中的元素。

Racer racer = racers.Find( r => r.FirstName == "Niki");

要获得于Predicate<T>类型匹配的所有项，而不是一项，可以使用FindAll()方法；

 

排序

List<T>类可以使用Sort()方法对元素排序。Sort()方法使用快速排序算法。

Sort()方法使用了几个重载的方法：

public void List<T>.Sort();
public void List<T>.Sort(Comparison<T>);
public void List<T>.Sort(IComparer<T>);
public void List<T>.Sort(Int32, Int32, IComparet<T>);

1. 只有集合中的元素实现了IComparable接口，才能使用不带参数的Sort()方法；

2. 如果需要按照元素类型不默认支持的方式排序，就应使用其他技术，如传递一个实现了IComparer<T>接口的对象。

3. 排序的另一种方式使用重载的Sort()方法。

调用Reverse()方法，逆转整个集合的顺序。

 

类型转换

使用List<T>类的ConvertAll<TOutput>()方法，可以把所有类型的集合转换为另一种类型。

ConvertAll<TOutput>()方法使用一个Converter委托：

public sealed delegate TOutput Converter<TInput, TOutput> (TInput from);

eg:
List<Person> persons = racers.ConvertAll<Person>( r => new Person(r.FirstName + " " + r.LastName));

只读集合

List<T>集合的AsReadOnly()方法返回 ReadOnlyCollection<T>类型的对象。

ReadOnlyCollection<T>类实现的接口与List<T>集合相同，但如若修改将抛出异常NotSupportedException异常。

ReadOnlyCollection<T>还实现了IReadOnlyCollection<T>和IReadOnlyList<T>接口。

 

 

队列

Queue<T> 命名空间 System.Collections.Generic

队列是其元素以先进先出（FIFO）的方式来处理的集合。

 

可以使用多个队列，一个队列对应一个优先级。打印队列和线程队列是这样的。

可以为一组队列建立一个数组，数组中的一项代表一个优先级。

 

在内部Queue<T>类使用T类型的数组；它实现ICollection和IEnumerable<T>接口。

因为没有实现IList<T>接口，所以不能用索引器访问元素。

Queue<T>方法如下：

Count
Enqueue
Dequeue
Peek //从队列头部读取一个元素但不删除它
TrimExcess //重新设置队列的容量，Dequeue()方法从队列中删除元素，但不会重新设置队列容量，要从队列的头部去除空元素，应使用TrimExcess()方法

多线程可以同时访问，但要是用lock语句锁定队列的访问：

public class DocumentManager {
	private readonly Queue<Document> documentQueue = new Queue<Document>();
 	public void AddDocument(Document doc) {
		lock (this) {
			documentQueue.Enqueue(doc);
		}
	}

	public Document GetDocument() {
		Document doc = null;
		lock (this) {
			doc = documentQueue.Dequeue();
		}
		return doc;
	}

	public bool IsDocumentAvailable {
		get { return documentQueue.Count > 0; }
	}
}

栈

栈是一个后进先出（LIFO）的容器

与Queue<T>类相同，Stack<t>类实现了IEnumerable<T>和ICollection接口。

成员列表：

Count
Push
Pop
Peek
Contains

在foreach方法中，使用IEnumerable接口迭代所有的元素；栈的枚举器不会删除元素，它只是逐个返回元素

 

链表

LinkedList<T>是一个双向链表

链表的有点事，如果将元素插入列表的中间位置，使用链表就会非常快。

在插入一个元素时，只需要修改上一个元素的Next引用和下一个元素的Previous引用，使它们引用所插入的元素。

在List<T>类中，插入一个元素时，需要移动该元素后面的所有元素。

链表的缺点：链表的元素只能一个接一个地访问，这需要较长的时间来查找位于链表中间或尾部的元素。

 

有序列表

如果需要基于键对所需集合排序，就可以使用SortList<TKey, TValue>类。这个类按照键给元素排序。

 

字典

.NET Framework提供了几个字典类，可以使用的最主要的类是Dictionary<TKey, TValue>

 

键的类型

用作字典中键的类型必须重写Object类的GetHashCode()方法；字典的性能取决于GetHashCode()方法的实现代码。

除了实现GetHashCode()方法之外，键类型还必须实现IEquatable<T>.Equals()方法，或者重写Object类的Equals()方法。

 

Lookup 类

Lookup<TKey, TElement>把键映射到一个值集上；Lookup<TKey, TElement>类在程序集System.Core中实现，用System.Linq命名空间。

 

Lookup<TKey, TElement>类不能像一般的字典那样创建，而必须调用ToLookup()方法，该方法返回一个Lookup<TKey, TElement>对象。ToLookup()方法是一个扩展方法，它可以用于实现了IEnumerable<T>接口的所有类。

 

有序字典

SortedDictionary<TKey, TValue>类是一个二叉搜索树，其中的元素根据键来排序。该键类型必须实现IComparable<TKey>接口。

如果键的类型不能排序，则还可以创建一个实现了IComparer<TKey>接口的比较器，将比较器用作有序字典的构造函数的一个参数。

 

 

集

包含不重复元素的集合成为“集（set）”。

.NET Framework包含两个集 HashSet<T> 和 SoredSet<T>, 它们都实现ISet<T>接口。

 

可观察的集合

如果需要集合中的元素何时删除或添加的信息，就可以使用ObservableCollection<T>类。

这个类是为WPF定义的，这样UI就可以得知集合的变化，因此这个类在程序集WindowsBase中定义；命名空间是 System.Collections.ObjectModel。

ObservableCollection<T>类派生自Collection<T>基类，该基类可以创建自定义集合，并在内部使用List<T>类。重写基类中的虚方法SetItem()和RemoveItem()，以触发CollectionChanged事件。这个类的用户可以使用INotifyCollectionChanged接口注册这个事件。

 

位数组

如果需要处理的数字有许多位，就可以使用BitArray类和BitVector32接口。

 

BitArray类

BitArray类位于名称空间System.Collections中，BitArray类可以重新设置大小，如果事先不知道需要的位数，就可以使用BitArray类，它可以包含非常多的位。

BitArray类是一个引用类型，它包含一个int数组，其中每32位使用一个新整数。

成员如下:

CountLength
Item [Get / Set]
SetAll
Not //取反
And / Or / Xor

辅助方法DisplayBits()遍历BitArray:

static void DisplayBits(BitArray bits) {
    foreach (bool bit in bits) {
        Console.Write(bit ? 1 : 0);
    }
}

var bits = new BitArray(8); //创建一个8位的数组
bits.SetAll(true); //把8位都设置位true，即 1
bits.Set(1, false); //把下标为1的位设置为false，即 0
bits[5] = false; //使用索引器设置
Console.Write("Initialized:");
DisplayBits(bits);
Console.WriteLine();

BitVector32结构

BitVector32结构位于命名空间System.Collections.Specialized中。

BitVector32结构是基于栈的，因此比较快。但仅能包含32位，存储在一个整数中。

 

如果事先知道需要的位数，就可以使用BitVector32结构替代BitArray类，效率较高；因为他是一个值类型。

一个整数可以存储32位，如果需要更多的位，可以使用多个BitVector32值或BitArray类。

BitVector32成员如下:

Data //Data属性把BitVector32结构中的数据返回为整数
Item //BitVector32的值可以使用索引器设置
CreateMask //这是一个静态方法，用于为访问BitVector32结构中的特定位创建掩码
CreateSection //这是一个静态方法，用于创建32位中的几个片段

 

不变的集合

如果对象可以改变其状态，就很难在多个同时运行的任务中使用。这些集合必须同步。如果对象不能改变其状态，就很容易在多个线程中使用。不能改变的对象成为不变的对象。

在VS2013中，Microsoft提供了一个新的集合库: Microsoft Immutable Collections。它包含不变的集合类 ----- 创建后就不能改变的集合类。

 

并发集合

从 .NET 4开始，命名空间System.Collections.Concurrent中提供了几个线程安全的集合类。

线程安全的集合可防止多个线程以相互冲突的方式访问集合。

为了对集合进行线程安全的访问，定义了IProducerConsumerCollection<T>接口。这个接口中最重要的方法是TryAdd()和TryTake()。TryAdd()方法尝试给集合添加一项，但如果集合禁止添加项，这个操作就可能失败。TryTake()雷同。

 

下面列出System.Collections.Concurrent名称空间中的类及功能:

ConcurrentQueue<T>
ConcurrentStack<T>
ConcurrentBag<T>
ConcurrentDictionary<TKey, TValue>
BlockingCollection<T>

ConcurrentXXXX集合是线程安全的，如果某个动作不适用于线程当前状态，他们返回false。

BlockingCollection<T>是对实现IProducerConsumerCollection<T>接口的任意类的修饰器，他默认使用ConcurrentQueue<T>类。

 

创建管道

将这些并发集合类用于管道是一种很好的应用：一个任务向一个集合类写入一些内容，同时另一个任务从该集合中读取内容。

 

性能

许多集合类都提供了相同的功能，但是，其性能常常有很大的区别。

在MSDN文档中，集合的方法常常有性能提示，给出了以大写O标记的操作时间：

O（1） //表示无论集合中有多少数据项，这个操作需要的时间都不变

O（long n） //表示对于集合执行一个操作需要的事件在最坏情况是是N

O（n） //表示操作需要的时间随集合中元素的增加而增加，但每个元素需要增加的时间不是线性的，而是呈对数曲线

 

 

总结

数组Array的大小是固定的，可以使用列表List作为动态增长的集合。

队列Queue以先进先出的方式访问元素，栈Stack以先进后出的方式访问元素。

链表LinkedList可以快速的插入和删除元素，但搜索操作比较慢。

通过键值对可以使用字典Dictionary，它的搜索和插入操作比较快。

集用于唯一项，可以是无序的HashSet，也可以是有序的SortedSet。

ObservableCollection类提供了列表中的元素发生变化时触发的事件。