C# 篇基础知识11——泛型和集合

.NET提供了一级功能强大的集合类,实现了多种不同类型的集合,可以根据实际用途选择恰当的集合类型。

除了数组 Array 类定义在System 命名空间中外,其他的集合类都定义在System.Collections 命名空间中。为了方便、快捷地操纵集合元素,.NET 专门为集合定义了一套接口,.NET 中的集合类都实现了一个或多个接口,并且每个集合类都拥有适合自身特点的独有方法,因此可以非常方便的操控集合中的元素。

为何对于集合类元素,可以使用foreach方法进行遍历,这是因所有的集合都直接或间接地实现了IEnumerable接口,这个接口定义了GetIEnumerator()方法,该方法返回了一个IEnumerator对象称为为迭代器,foreach语句就是通过访问迭代器而获取集合中元素的。

public interface IEnumerator

{  bool MoveNext();  //获取下一个元素

   object Current{get;}  //获取当前元素

   void Reset();  //将枚举数设置为其初始位置   }

ICollection接口也是一个很基础的接口,它继承于IEnumerable,并且添加了一个CopyTo()方法,一个Count属性以及两个用于同步的属性。

public interface ICollection : IEnumerable

{ void CopyTo(System.Array array, int index); //复制到数组

int Count { get; } //元素个数

bool IsSynchronized { get; } //是否同步

object SyncRoot { get; } //用于同步的对象  }

IList 接口和IDictionary 接口都继承于ICollection 接口。

Array类,C#为创建数组提供了专门的语法。数组有一个非常显著的优点,即可以根据下标高效地访问数组的元素;但是数组也有一个缺点,即在创建时数组的大小就已经确定了,不能动态地增加元素。Array 类有许多有用的方法,例如静态方法Sort()方法和Copy()方法,Sort()方法的功能是对数组排序,Copy()方法的功能是复制数组,它有三个参数,第一个参数是原数组,第二个参数是目标数组,第三个参数表示复制元素的个数。

1.泛型

泛型是C#2.0 推出的一个新特性,通过它可以定义像文档模板一样的类模板。

1)泛型的概念

在 ArrayList、Stack、Queue 等集合类中,元素的类型均为Object。由于.NET 中所有类都继承于Object,所以这些集合可以存储任何类型的元素。使用这些集合添加元素和读取元素时分别需要装箱和拆箱操作,例如:

ArrayList list = new ArrayList();

list.Add(10); //添加元素

int n = (int)list[0];

这样做有三个缺点:

第一,在装箱、拆箱的过程中,可能会造成一定的性能损失。

第二,无论什么样的数据都能往集合里放,不利于编译器进行严格的类型安全检查。

第三,显式转换会降低程序的可读性。

为解决这些问题,C#2.0推出了泛型(Generic),泛型集合类和非泛型集合类功能上基本一致,唯一的区别是泛型集合类的元素类型不是Object,而是自己指定的类型。

例如可以自行定义一个队列泛型类public class MyQueue<T>{},,泛型类与普通类的区别是它具有一个类型参数列表<T>,在整个类里用T 代表元素类型。在定义类的时候,元素类型是未知的,是一个抽象的类型。在使用泛型类时,应为抽象类型T 指定具体类型。例如:

//使用时用int 替换抽象类型T

MyQueue<int> q1 = new MyQueue<int>(20);

//用char 替换抽象类型T

MyQueue<char> q2 = new MyQueue<char>(20);

用具体值类型int代替抽象类型T时,公共语言运行时在进行JIT 编译时,会用int 代替泛型类中的T,创造出一个以int 为元素类型的新类,这个过程称为泛型类型的实例化(Generic Type Instantiation)。不同的值类型,会实例化出不同的新类。但对于所有引用类型共享同一个MyQueue实例,因为集合中只会存储对象的引用符,而所有对象的引用符都占用4 个字节。

除了定义泛型类,还可定义泛型方法、泛型接口、泛型结构体、泛型委托等。和泛型类一样,使用泛型方法时也要为把抽象类型具体化。泛型的定义中可含有多个类型参数。例如泛型类class Dictionary<K,V>{…}。

泛型最常见的用途是定义泛型集合,泛型集合和相对应的非泛型集合功能基本相同,但泛型集合能提供严格的类型检查,具有较强的安全性。此外,如果元素类型为值类型,泛型集合的性能通常优于非泛型集合。泛型集合类定义在System.Collections.Generic 命名空间中。

2)列表

列表在非泛型集合中用 ArrayList 类实现,在泛型集合中用List<T>类实现。列表与数组类非常类似,其区别是数组不能改变大小,而列表可以改变大小。

List<string> basketballPlayers = new List<string>(); //默认容量为0

List<string> basketballPlayers = new List<string>(10); //容量为10

basketballPlayers.Capacity = 10;//改变列表的容量

当列表的容量改变时,系统会分配新的内存空间,创建一个全新的列表,然后把原列表的内容复制到新列表中,最后删除原列表。向已经装满的列表添中加新元素时,列表会采用“翻倍”的办法增加容量。现在basketballPlayers 是一个容量为10 的列表,当添加第11 项时,就会创建一个新的容量为20 的列表。容量翻倍貌似浪费内存空间,但这是一个使列表“合适增长”的高效方法。如果每次添加一个新元素就重新创建一次列表,其效率低下可想而知。访问列表元素的方式和数组一样,都是通过索引来访问。例如:string name = basketballPlayers[2]; 。List<T>类的部分重要方法:

Add()方法,Add()方法用于向列表中添加元素,新元素位于列表的末尾,例如basketballPlayers.Add("姚明");。

Remove()方法,Remove()方法用于删除元素,参数为欲删除的对象。如果删除成功,返回true;如果删除不成功或欲删除的对象不存在,返回false,例如basketballPlayers.Remove("邓肯");。

RemoveAt()方法,使用Remove()方法时,系统需要在列表中进行搜索,以便找到匹配的元素,这个搜索过程需要花费一定的时间。RemoveAt()方法的参数为元素的索引,可以直接删除指定位置上的元素。例如basketballPlayers.RemoveAt(2);。

Insert()方法,Insert()方法用于在指定位置插入元素。basketballPlayers.Insert(2, "诺维斯基");

RemoveRange()方法,RemoveRang()方法可以一次从列表中删除多个元素,它的第一个参数表示起始位置,第二个参数表示从该位置起删除几个元素。例如basketballPlayers.RemoveRange(1, 3);。

AddRange()方法,AddRange()方法用于一次性添加一批元素,它的参数是一个集合,集合中包含所有要添加的元素。例如:string[] names ={ "邓肯", "阿伦", "加索尔" }; basketballPlayers.AddRange(names);。

GetRange()方法,GetRange()方法用于获取列表中指定范围内的元素,它的第一个参数表示起始位置,第二个参数表示从该位置起读取几个元素。List<string> bestPlayers = basketballPlayers.GetRange(0,3);。

3)栈

栈是一种后进先出(Last In First Out,LIFO)的集合类型,栈在非泛型集合中用Stack类实现,在泛型集合中用Stack<T>类实现,下面介绍一下泛型类Stack<T>中的重要属性和方法。

Push()方法,在栈顶添加元素的操作称为压栈,用Push()方法实现,例如Stack<char> alphabet = new Stack<char>(); alphabet.Push('A');。

Pop()方法,从栈顶取出元素的方法称为出栈,用 Pop()方法实现,例如char leter = alphabet.Pop();。使用Pop()方法后元素将从栈中删除。

Peek()方法,用来读取栈顶的元素,但不删除它。

4)队列

队列(Queue),队列的元素只能从队头取出,从队尾加入,是一种先进先出(First In First Out,FIFO)的集合类型。队列在非泛型集合中用 Queue 类实现,在泛型集合中用Queue <T>类实现,下面介绍一下泛型类Queue <T>中的重要属性和方法。

Enqueue()方法,在队尾添加元素称为入队,用 Enqueue()方法实现。例如

Queue<char> alphabet = new Queue<char>();

alphabet.Enqueue('A');

alphabet.Enqueue('B');

遍历时,也将按入队的顺序显示。

Dequeue()方法,从队头取出元素称为出队,用Dequeue()方法实现,取出的元素会被删除。

Peek()方法,Queue 类也有Peek()方法,它用来读取队头的元素,但不删除元素。

 

5)排序列表

排序列表与列表很相似,区别是排序列表中的每个元素都与一个用于排序的键(Key)关联,元素按键的顺序排列。实际上排序列表内部维护两个数组,一个数组用于存储元素,另一个数组用于存储与元素关联的键。排序列表在非泛型集合中用 SortedList 类实现,在泛型集合中用SortedList<TKey,TValue>类实现,下面介绍一下泛型类SortedList<TKey, TValue>中的重要属性和方法。

通过 SortedList<TKey, TValue>类的Add()方法可以向集合中添加元素,它有两个参数,第一个参数是与元素关联的键,第二个参数是元素的值。例如:

SortedList<int, string> medalTable = new SortedList<int, string>(); medalTable.Add(3, "吴敏霞");

medalTable.Add(1, "郭晶晶");

medalTable.Add(2, "哈莉娜");

//输出结果

for (int i = 0; i < medalTable.Count; i++)

{Console.WriteLine(medalTable.Keys[i] + " : " + medalTable.Values[i]);}

SortedList<TKey, TValue>类的Count 属性为列表中实际存储的元素个数,Keys 属性为所有键的集合,Values 属性为所有值的集合。上述程序输出结果为:1:郭晶晶 2:哈莉莉 3:吴敏霞。可以发现,排序列表中的元素并不是按添加顺序排列的,而是按照键的顺序排列的。

(6)散列表

散列表(Hashtable)又叫做字典(Dictionary),能够非常快速的添加、删除和查找元素,是现在检索速度最快的数据结构之一。

散列函数能根据Key 直接计算出元素的索引,能否设计一个有效的散列函数,是解决问题的关键,然而现实世界并非总是那么完美,实际数据也并不总是那么配合散列函数,会出现各种各样的问题。一种问题是元素的散列码不连续,这种问题很好解决,大不了让不连续的地方空在那里即可,虽然有点浪费空间,但因为散列表的读写速度很快,我们“以空间换取了时间”。另一种问题是多个Key具有相同的散列码。。.NET采用了一种精心设计的方法解决冲突①,其基本思想是先通过散列函数计算出基位置,如果发现基位置已经被占用,就根据一定的算法向下寻找,直到找到空位置为止。当然,与之对应,检索元素时也要采取相同的方法。。在实际问题中,散列函数有很多种,我们需要根据Key 的类型和整个集合的特征设计恰当的散列函数。一个设计良好的散列表,应当能使元素均匀分布。

这里讲了散列表的基本原理,实际问题要复杂得多,但基本思想就是一条:用散列函数把元素映射到相应的位置。散列表中的元素可以是基本类型数据,也可以是非常复杂的包含很多成员变量的对象,这时我们需要挑选一个合适的成员变量做键(Key),而整个元素则被称为值(Value)。,.NET 中所有的类都有一个从Object 类继承来的GetHashCode()方法,散列表就是根据这个散列函数计算散列码的。任何类型都可以用作Key,如果你用.NET中预定义的类做Key,散列表就通过该类的GetHashCode()方法计算散列码;如果你想用自己定义的类做Key,一般需要重写GetHashCode()方法。除此之外,散列表还允许我们根据需要指定散列函数,这时不管你的Key 为何种类型,都使用你所指定的散列函数进行计算。

散列表在非泛型集合类中用Hashtable 类实现,在泛型集合类中用Dictionary<TKey,TValue>类实现,下面我们介绍泛型类Dictionary<TKey, TValue>的重要属性和方法。

构造函数

Dictionary<TKey, TValue>类为我们重载了7 个构造函数,使用该泛型类时需要指明键类型和值类型。

Dictionary<string,Color> colorTable1 = new Dictionary<string,Color>();

除此之外,我们还可为字典提供自定义的GetHashCode()方法。

Dictionary<string,Color> colorTable1 = new Dictionary<string,Color>(comparer);

其中参数comparer 是一个实现了IEqualityComparer 接口的对象,IEqualityComparer 接口定义了两个方法,Equals()方法用来判断两个对象是否相等,GetHashCode()方法用来为字典提供散列函数,这时不管字典中的Key 为何种类型,都将通过comparer 对象提供的散列函数进行散列。为了使字典能够正常工作,编写GetHashCode()方法有相当严格的要求。

Add()方法

通过 Add()方法向字典中添加元素,它接受两个参数,第一个参数是与元素关联的键(Key),第二个参数是元素的值(Value),字典将根据Key 计算出元素的存储位置。例如:

//创建元素

Color red = new Color("Red", 255, 0, 0);

Color green = new Color("Green", 0, 255, 0);

Color orange = new Color("Orange", 255, 200, 0);

//建立字典

Dictionary<string, Color> colorTable = new Dictionary<string, Color>();

//向字典中添加元素

colorTable.Add(red.Name, red);

colorTable.Add(green.Name, green);

colorTable.Add(orange.Name, orange);

先创建了一个字典,然后向字典中添加了三个Color 对象。这里选取Color 对象的Name 属性作为Key,通过它计算元素在字典中的位置。

Key为索引设置或读取元素

colorTable["Blue"] = new Color("Blue", 0, 0, 255); //设置元素:

Console.WriteLine("新添加的元素为: " + colorTable["Blue"]);//输出元素

以这种方法向字典中添加元素与用 Add()方法有一点区别:当字典中已存在该Key 时,Add()方法会引发异常,而以Key 为索引则不会,只是用新值替换旧值而已。

Keys属性

通过字典的 Keys 属性可以获取字典的所有键。例如foreach (string key in colorTable.Keys){}

Values属性

通过字典的Values属性可以获取字典的所有元素的值,例如:

Console.WriteLine("字典中的值:");

foreach (Color value in colorTable.Values)

{Console.WriteLine(value);}

其结果如下图所示。

 

ContainsKey()方法,ContainsKey()方法用于检验字典中是否包含特定的键。因为参数提供了键的信息,所以可通过散列函数找到元素的位置,只需计算一次,效率很高。例如:if (colorTable.ContainsKey("Red")){…}

ContainsValue()方法,用于检验字典中是否包含特定的Value。由于没有键的信息,该方法需要检索整个字典的来寻找元素,平均需要检索n/2 次。例如if(colorTable.ContainsValue(black)){}

Remove()方法,通过字典的 Remove()方法可以删除与指定的键关联的元素。例如:colorTable.Remove("Orange");

综上所述,字典是一种检索速度非常快的数据结构,在拥有海量数据的问题中往往能发挥非常重要的作用。

2.类型约束

在泛型中,类型参数T 可以实例化为任何数据类型,这在某种情况下会产生问题。

//T 代表某种动物类

class AnimalFamily<T>

{//用来存储动物的家庭成员

private List<T> family = new List<T>();

//方法:添加成员

public void Add(T member)

{family.Add(member);}

//方法:显示所有成员

public void Display()

{  foreach (T member in family)

{Console.WriteLine(member.name);}

}

}

主述程序会出现以下编译错误,这是因为member 的类型为T,而T 为何种具体类型并不确定,因此就不能确定member 是否拥有成员变量name。

 

解决办法是对抽象类型 T 进行约束(Constraint),限制T 的取值范围。例如将代码改成如下,在泛型类AnimalFamily<T>中,我们通过where 关键字把类型T 的范围限制在Animal类和它的派生类中,这样就确保对象member 中一定包含成员name,编译也能顺利通过了。

class Animal

{//公有变量

public string name;

//构造函数

public Animal(string nameValue)

{name = nameValue;} }

//泛型类

class AnimalFamily<T> where T : Animal

{…}

见贤思齐,见不贤而自省
原文地址:https://www.cnblogs.com/Sweepingmonk/p/10868106.html