1.泛型类
1泛型方法:只需要在方法名字后面加<T,T1,T2> 为了确定参数类型和返回值类型，当然也可以参数和返回值类型定义成普通类型
2 泛型类：在类名后面添加<T>,目的把类型传入类当中
3 泛型接口：在接口后面添加泛型，目的把类型传接口当中
//泛型字母可以写任意的字母 class People<TTest1,TTest2> { public string Name { get; set; } public TTest1 A1 { get; set; }// 属性的类型和传入TTest1类型保持一致 public TTest2 A2 { get; set; } // 属性的类型和传入TTest2类型保持一致 public void F1<T>(T c ,TTest1 a,TTest2 b) { dynamic sum = (dynamic)c + (dynamic)a + (dynamic)b; Console.WriteLine(sum); } } //泛型接口 interface IPeople<T> { int Age { get; set; } T Name { get; set; } void F1<T1>(T a,T1 b); } class Student : IPeople<float> { public int Age { get; set; } public float Name { get; set; } public void F1<T1>(float a, T1 b) { Console.WriteLine(a + b.ToString()); } }static void Main(string[] args) { People<int,float> p1 = new People<int,float>(); //传入的int 和float类型 p1.F1<float>(10.1f, 10, 20.2f); People<string,string> p2 = new People<string,string>(); p2.F1<string>("+++++++", "---------", "红客联盟白宫服务网站挂上中国国旗"); Student s1 = new Student(); s1.Age = 10; s1.Name = 19.1f; s1.F1<int>(10, 20); Console.ReadKey(); }2.泛型约束
泛型约束: 泛型本身没有限制类型但是通过 where对泛型进行限制范围
本身泛型没有类型限制的
where T : struct限制T只能值类型
where T : class限制T只能是引用类型
where T : new() T必须有一个不带参数的构造函数的类
where T : IPeople T必须是实现接口的类型 或者实现接口类的派生类， 本例可以是Student、还可以继承于Student的子类：SmallStudent
where T : U限制传入类型 要么是T和U同一个类型、要么T是U的子类
eg：
//本身泛型没有类型限制的 static void Test1<T>(T a) { } // where T : struct 限制T只能值类型 static void Test2<T>(T a,T b) where T : struct { } //where T : class 限制T只能是引用类型 static void Test3<T>(T a, T b) where T : class { } //where T : new() T必须有一个不带参数的构造函数的类 static void Test4<T>(T a, T b) where T : new() { } //where T : IPeople T必须是实现接口的类型 或者实现接口类的派生类， 本例可以是Student、还可以继承于Student的子类：SmallStudent static void Test5<T>(T a, T b) where T : IPeople { } // where T : U 限制传入类型 要么是T和U同一个类型、要么T是U的子类 static void Test6<T,U>(T a, U b) where T : U { } } interface IPeople { } //接口 class Student:IPeople { } // Student实现接口 class SmallStudent:Student { } // SmallStudent继承了 Student //定义people类 class People { public People() { } // 无参数构造 public People(int a) { }// 有参数的构造 }static void Main(string[] args) { //调用Test1方法 Test1<int>(10); Test1("hello"); Test1(DateTime.Now); //调用Test2方法 Test2(10, 10); //Test2<DateTime,int>(DateTime.Now, 10);报错 //Test2("11", 10);报错 //调用Test3方法 Test3("11", "11"); // Test4方法 Test4(new People(),new People()); // Test5方法 Test5(new Student(), new SmallStudent()); //Test6方法 Test6(new People(), new People()); Test6(new SmallStudent(), new Student()); // Test6( new Student(), new SmallStudent()); 报错 Console.ReadKey(); }3.hash表
hash表:和字典很类似，存储时候也是键值对的方法进行存储的，通过键获取对应的值，和字典不同地方在于，hash表存储键值对类型不固定
Hashtable hashtable = new Hashtable(); 创建hash表
1.添加键值对
hashtable.Add(1, 2);
hashtable.Add("name", "张三");
2 .查询键对应的值
Console.WriteLine(hashtable[1]);//获取对应键的值
3.遍历hash所有的keys
foreach (var item in hashtable.Keys)
{
Console.WriteLine(item+"--------");
}
4.遍历hash所有的values
foreach (var item in hashtable.Values)
{
Console.WriteLine(item + "+++++++");
}
5. 遍历hash所有键值对
foreach (DictionaryEntry item in hashtable)
{
Console.WriteLine(item.Value+"?????????");
}
Console.ReadKey();
6 .清空键值对
hashtable.Clear();
7.指定键进行移除
hashtable.Remove(1);
8 .包含这个键
Console.WriteLine(hashtable.ContainsKey("name"));
9. 修改
hashtable["name"] = "你好";
10. 键值对个数
Console.WriteLine(hashtable.Count);
4.堆栈_stack_和队列
本节是按照线性数据结构据，数存储方式进行对比的
栈:对要操作元素会进行一个后进先出的操作，例如：现实场景电梯，先进去的人最后才出来，后进去的人先出来
添加元素称为入栈
取出一个元素操作称为出栈
Stack<string> stack = new Stack<string>();---存放字符串栈结构 stack.Push("张三");--- 入栈 stack.Push("李四"); stack.Push("王五"); string name = stack.Pop();---出栈 Console.WriteLine(name+"-----");---王五 Console.WriteLine(stack.Peek()); ---获取栈顶元素 李四 Console.WriteLine(stack.Count); ---2个 //stack.Clear(); ---清空栈 //stack.ToArray() ; ---转成数组队列:对元素进行先进先出的操作 例如现实场景排队买饭
添加元素一般入队操作
取出元素一般出队操作
Queue<string> queue = new Queue<string>(); queue.Enqueue("马化腾"); ---入队 queue.Enqueue("马云"); queue.Enqueue("马嘉祺"); Console.WriteLine(queue.Count); Console.WriteLine(queue.Dequeue()); ---出队马化腾 Console.WriteLine(queue.Peek());---获取队顶元素马云 // queue.Clear(); 清空队列按照存储区域分别解释堆和栈
特性 栈（Stack） 堆（Heap）
存储内容 值类型、方法参数、局部变量 引用类型对象、装箱的值类型
生命周期 随作用域结束自动释放 由垃圾回收器（GC）管理
分配速度 快（指针移动） 慢（动态查找可用内存）
内存布局 连续内存 非连续（可能产生碎片）
访问方式 直接 通过引用间接访问
线程关联 每个线程独有 所有线程共享
管理方式 编译器自动管理 垃圾回收器（GC）管理
