泛型 集合 堆栈 队列 哈希表 字典

小例子

/*
（1）创建小孩Baby类，实现ISpeak接口
（2）定义求面积的接口IArea与求体积的接口IVolumn，
    定义长方体类分别实现IArea与IVolumn接口
（3）定义接口IBattle，该接口包含功能Attack()，Move()，Jump()；
    定义接口IRest，该接口包含功能SitDown()，Sleep()。
    定义接口IPlayer，接口IPlayer继承IBattle与IRest。
    定义Soldier类实现IPlayer接口
*/

//（1）创建小孩类 实现接口
class Baby : ISpeak
{
    //实现接口的方法
    public void Speak(){
        
    }
}
//接口
interface ISpeak{
    //接口里有个说话的方法
    void Speak();
}
//（2）
//求面积的接口
interface IArea{
    int GetArea(int x, int y);
}
//求体积的接口
interface IVolumn{
    int GetVolumn(int x, int y, int z);
}
//长方体类，实现两个接口
class Cube : IArea , IVolumn
{
    public int GetArea(int x, int y){
        return x * y;
    }
    public int GetVolumn(int x, int y, int z){
        return x * y * z;
    }
}
//（3）
interface IBattle{
    void Attack();
    void Move();
    void Jump()；
}
interface IRest{
    void SitDown();
    void Sleep();
}
interface IPlayer : IBattle , IRest
{
   
}

泛型

我们在编写程序时经常遇到两个模块的功能非常相似，只是因为参数类型不同，所以分别写多个方法处理每种数据类型，因为方法的参数类型不同没法重用同样功能的代码。

装箱
	可分为值类型与引用类型
	所有的鸡肋是object
	从其他的值类型 引用类型 转成 object 这个叫装箱
	举个例子
	int a = 7;
	object obj = a;
拆箱
	从 object 转成 其他的值类型 引用类型 这个叫拆箱
	float b = (float)obj;

会出现装箱、拆箱操作，这将在托管堆上分配和回收大量的变量，若数据量大，则性能损失非常严重
在处理引用类型时，虽然没有装箱和拆箱操作，但将用到数据类型的强制转换操作，增加处理器的负担

Add<int>(3,4);
Add(3,4);
Add<float>(3f,4);
Add(3f,4);

泛型实现交换：

C#中的泛型能够将类型作为参数来传递，即在创建类型时用一个特定的符号如“T”来作为一个占位符，代替实际的类型，等待在实例化时再用一个实际的类型来代替：

public static void Swap<T>(ref T value0, ref T value1)
{
    T temp = value0;
    value0 = value1;
    value1 = temp;
} 

集合

为什么要用集合呢？

答：因为数组的局限性

（1）限定个数
（2）比如删除下标对应的内容，内容删除了，但是下标还在
（3）数组不能动态增加
（4）存储的都是相同类型的

集合与数组不同的是，集合的大小可以动态调整，可以在运行时添加或删除元素。

集合可范围两类：泛型集合与非泛型集合

泛型集合类一般位于System.Collections.Generic名称空间，
非泛型集合类位于System.Collections名称空间。
此外，System.Collections.Specialized名称空间中也包含一些有用的集合类。

System.Collections

object 装箱拆箱

类	描述和用法
动态数组(ArrayList)	它代表了可被单独索引的对象的有序集合。它基本上可以替代一个数组。但是，与数组不同的是，您可以使用索引在指定的位置添加和移除项目，动态数组会自动重新调整它的大小。它也允许在列表中进行动态内存分配、增加、搜索、排序各项。
堆栈(Stack)	它代表了一个后进先出的对象集合。当您需要对各项进行后进先出的访问时，则使用堆栈。当您在列表中添加一项，称为推入元素，当您从列表中移除一项时，称为弹出元素。
队列(Queue)	它代表了一个先进先出的对象集合。当您需要对各项进行先进先出的访问时，则使用队列。当您在列表中添加一项，称为入队，当您从列表中移除一项时，称为出队。
哈希表(HashTable)	它使用键来访问集合中的元素。当您使用键访问元素时，则使用哈希表，而且您可以识别一个有用的键值。哈希表中的每一项都有一个键/值对。键用于访问集合中的项目。

System.Collections.Generic

类	描述和用法
Dictionary<Tkey,Tvalue>	同哈希表一样,标示根据键进行的键值对的集合.不同的是对键值进行了类型限定
List	同ArrayList一样,表示通过索引访问对象的列表.不同的是对存储的对象进行了类型限定
Stack	同Stack一样,不同的是对存储的对象进行了类型限定
Queue	同Queue一样,不同的是对存储的对象进行了类型限定

ArrayList

类	描述和用法
Add()	将对象添加到ArrayList的结尾处
Insert()	将元素插入ArrayList的指定索引处
Remove()	从ArrayList中移除特定对象的第一个匹配项
RemoveAt()	移除ArrayList的指定索引处的元素
Reverse()	将整个ArrayList当中元素的顺序反转
Contains()	确定某元素是否在ArrayList中
Clear()	从ArrayList中移除所有元素

ArrayList array = new ArrayList();
//添加
array.Add(1);
array.Add(2);
//修改
array[0] = 3;
//插入
//在零号位置插入四
array.Insert(0, 4);
//移除
//这种移除的是某个元素
array.Remove(2);  
//通过索引移除
array.RemoveAt(0);
//反转
array.Reverse();
//是否包含
bool res = array.Contains(3);//如果存在就返回true 否则返回false
//清除
array.Clear();
//长度
array.Count;//普通数组的长度都是Length
//返回某个元素的索引
int index = array.IndexOf(3);

List< T >

List类是ArrayList类的泛型等效类 （和ArrayList的唯一区别在于这个是带泛型的）
同样实现了IList接口,IEnumrator接口和ICollection
与ArrayList不同的是,声明集合时需要声明集合内部的数据类型,即T的类型.
安全的集合类型
某种情况时,在处理值类型时其处理速度比ArrayList快的多。

List<int> list = new List<int>();
list.Add(3);

接口	描述和用法
IEnumerator	这个接口定义了方法GetEnumerator(),返回一个实现了IEnumerator接口的枚举.如果将foreach语句用于集合,就需要实现该接口
ICollection	ICollection接口由泛型集合类实现.使用这个接口可以获取集合中的元素个数****(count),把集合复制到数组中(CopyTo()),还可以添加和删除元素
IList	IList接口用于可通过位置访问其中的元素列表,这个接口定义了一个索引器,可以在集合指定位置插入或删除某些项.IList接口派生自ICollection接口
IDictionary<TKey,TValue>	IDictionary<TKey,TValue>接口由包含键和值的泛型集合类实现.使用这个接口可以访问所有的键和值.使用键类型的索引器可以访问某些项,还可以添加或删除某些项

堆栈Stack

后进先出(LIFO)的一种数据结构,本质上堆栈也是一种线性结构   <----线性结构 比如一条绳上的蚂蚱 只要两头
线性结构的基本特点:即每个节点有且只有一个前驱结点和一个后续节点
随着像Stack中添加元素,容量通过重新分配按需自动增加
可以接受null作为有效值
允许重复的元素
不安全的数据结构
其泛型为Stack<T>

类	描述和用法
Push()	将对象插入Stack的顶部.(入栈操作)
Pop()	移除并返回Stack顶部的对象.(出栈操作)
Peek()	返回位于stack顶部的对象,但不移除.
Contains()	确定某元素是否在栈中
Clear()	从statck中移除所有对象
Count	获取栈中包含的元素

//堆栈
Stack<int> stack = new Stack<int>();
//入栈
stack.Push(1);
stack.Push(2);
stack.Push(3);
//出栈
//出栈可以弹出作为返回值，可以接收
int num = stack.Pop();//3
num = stack.Pop();//2
num = stack.Pop();//1
//看一看现在栈顶是谁
num = stack.Peek();

队列Queue

先进先出(FIFO)的一种数据结构
可以接受null作为有效值
允许重复的元素
不安全的数据结构
其泛型为Queue<T>

类	描述和用法
Enqueue()	将对象添加到Queue的结尾处,入队.
Dequeue()	移除并返回位于Queue开始处的对象
Peek()	返回位于Queue开始处的对象但不将其移除
Contains()	确定某元素是否在Queue中
Clear()	从Queue中移除所有对象
Count	获取Queue中包含的元素数

//队列
Queue<int> queue = new Queue<int>();
//入队
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
//出队
num = queue.Dequeue();//1
num = queue.Dequeue();//2
num = queue.Dequeue();//3

哈希表HashTable

类	描述和用法
Add()	将指定的键和值添加到哈希表中
Clear()	从 Hashtable 中移除所有的元素。
ContainsKey()	判断 Hashtable 是否包含指定的键。
ContainsValue()	判断 Hashtable 是否包含指定的值。
Remove()	从 Hashtable 中移除带有指定的键的元素。
Keys	获取一个ICollection，包含 Hashtable 中的键。
Values	获取一个ICollection，包含Hashtable中的值

//哈希表
Hashtable hashtable = new Hashtable();
//增加键值对
hashtable.Add("xiaowang", new Person(3));
hashtable.Add("xiaoli", new Person(5));
hashtable["xiaozhang"] = new Person(6);//也支持索引器

字典Dictionary

类	描述和用法
Add(TKey, TValue)	将指定的键和值添加到字典中。
Clear()	将所有键和值从 Dictionary<TKey,TValue> 中移除。
ContainsKey(TKey)	确定是否 Dictionary<TKey,TValue> 包含指定键。
ContainsValue(TValue)	确定 Dictionary<TKey,TValue> 是否包含特定值。
Remove(TKey)	将带有指定键的值从 Dictionary<TKey,TValue> 中移除。
TryGetValue(TKey, TValue)	获取与指定的键关联的值。
Keys	获得一个包含 Dictionary<TKey,TValue> 中的键的集合。
Values	获得一个包含 Dictionary<TKey,TValue> 中的值的集合。

//字典
Dictionary<string,Person> dic = new Dictionary<string,Person>();
Person person = new Person(3);
//增加
dic.Add("xiaowang", person);
//包含某个Key
res = dic.ContainsKey("xiaowang");
//包含某个Value
res = dic.ContainsValue(person);
//移除  移除的一对
dic.Remove("xiaowang");
//遍历字典所有的key，无序的
foreach(string str in dic.Keys){
    Console.WriteLine(str);
}
//遍历字典所有的Value，无序的
foreach(Person p in dic.Values){
    Console.WriteLine(p.ToString());
}