C#Lambda表达式、C#中集合类型、哈希表、SortedList 排序列表、堆(Heap)栈(Stack)、Queu列队 - 详解

*Lambda表达式:

//Lambda表达式 本质上是匿名函数 (没有名字的函数)
// 如果代码块中和类中有相同名称的函数  会调用内部的方法
Test();
//函数不仅能定义在类中，也可以定义在代码块中
//格式:
//返回值类型 函数名 (形参) {具体内容}
void   Test()
{ Console.WriteLine("这个函数在代码块中") }
//需求:定义一个计算加法的函数 要求有返回值
int Sum(int a, int b)
{ return a + b; }
Console.WriteLine(Sum(5, 5));//10
int[] ints = { 1, 2, 3, 4, 5, 6, };
Console.WriteLine(Array.Find(ints, Test1));//2
bool Test1(int value)
{ return value % 2 == 0; }
//Lambda表达式  用于创建一个函数  常用作委托, 回调
//格式:
//Func<参数1的类型，参数2的类型，返回值类型>方法名 = (参数1，参数2) => {函数的内容};
Func fnNamel = (int a, int b) => { return a > b; };
//调用的时候和普通函数相同
Console.WriteLine(fnNamel(5, 6));//False
//Lambda表达式的声明可以简化
//函数的实现中，参数类型可以省略
Func fnName2 = (a, b) => { return a < b; };
//如果只有一个参数，可以省略()
Func fnName3 = a => { return a % 2 == 0; };
//如果函数中只有一个表达式,可以省略{}和return：
Func fnName4 = a => a % 2 == 0;
//如果函数中有两个表达式
Func fnName5 = (a, b) => a > b;

*C#集合（Collection）:

c#中集合类Collection 是专门用于数据存储和检索的类，类中提供了堆栈，队列，列表，哈希表的支持。大多数集合类都实现了相同的接口

集合类的用途多种多样，例如可以动态的为元素分配内存，根据索引访问列表项等等。这些类创建Object类的对象集合

 •C#中集合类型:

以下是以System.Collection命名空间为例，该命名空间提供的集合类型如下

类                                               描述和用法

动态数组ArrayList                   不固定 长度 和存储 数据类型 的数组，可以存储 任意类型的数据，并且长度会随着内容 增加减少而改变

List                                          类似于ArrayList，只是List 只能存储 相同类型的数据，List的长度 也是 不固定的

字典（Dictionary）                 类似于List，只能 存储 固定类型 的数据，长度也 不固定

哈希表（Hashtable）             哈希表可以 使用键 来访问 集合中的元素。哈希表中的每一项 都有 一个键/值对组成，键用于访问集合中的指定项

排序列表                                 存储 一系列按照 键 进行排序的 键/值对，可以通过 键/索引 访问这些 键/值对

Stack:堆栈                              堆栈类表示一个后进先出的对象集合，当需要对项目进行后进先出的访问，则可以使用堆栈

 Queue:队列                           队列类与堆栈类似，它代表了一个先进先出的对象集合，当需要对项目进行先进先出的访问

•哈希表（Hashtable）:

//Hashtable Hash表 表示一系列 由键和值组成的数据，使用键访问集合中的元素
//Hash中添加键值对，键必须唯一，数据类型不限制
//申明
Hashtable hashtable = new Hashtable()
{
    {6,"a" },
    {"1a",3 }
};
// 变量名.Add  向Hash表中添加数据
//注意:不能出现相同键,值无所谓
hashtable.Add("吴亦凡", 999);
// 变量名.Remove  删除指定键的对应数据
hashtable.Remove(6);
// 变量名.Clear  清空hash表
hashtable.Clear();
//只能改 键对应的值内容 无法修改键
hashtable[6] = 66;
//通过键查看值  找不到会返回空
Console.WriteLine(hashtable[6]);//a
Console.WriteLine(hashtable["6"]);//null
//通过键查看是否存在
if(hashtable.Contains("1a"))
{Console.WriteLine("存在键为1a的键值对");}
//通过值查看是否存在
if(hashtable.ContainsValue(3))
{Console.WriteLine("存在值为3的键值对");}
// 变量名.Keys  获取Hash表中 所有 的键
Console.WriteLine(hashtable.Keys);//System.Collections.Hashtable+KeyCollection
// 变量名.Values  获取Hash表中 所有 的值
Console.WriteLine(hashtable.Values);//System.Collections.Hashtable+ValueCollection
// 变量名.Count  获取Hash表中 包含的 键值对 的个数
Console.WriteLine(hashtable.Count);//2
//遍历
//1.遍历所有键
foreach (object item in hashtable.Keys)
{ Console.WriteLine("键"+item);
Console.WriteLine("值"+hashtable[item]);}
//2.遍历所有值
foreach (object item in hashtable.Values)
{Console.WriteLine("值"+item);}
//3.键值对一起遍历
foreach (DictionaryEntry item in hashtable)
{Console.WriteLine("键"+item.Key+"值"+item.Value); }
//4.迭代器遍历法
IDictionaryEnumerator myEnumerator = hashtable.GetEnumerator();
bool flag = myEnumerator.MoveNext();
while(flag)
{Console.WriteLine("键:"+ myEnumerator.Key +"值:"+ myEnumerator.Value);
 flag = myEnumerator.MoveNext();}

Hashtable 类中的属性:

下表中列出了 Hashtable 类中一些常用的属性：

属性	描述
Count	获取哈希表中包含的键值对的个数
IsFixedSize	获取一个值，用来表示哈希表是否具有固定大小
IsReadOnly	获取一个值，用来表示哈希表是否只读
Item	获取或设置与指定键关联的值
Keys	获取一个 ICollection，其中包含哈希表中的 键
Values	获取一个 ICollection，其中包含哈希表中的值

Hashtable 类中的方法:

下表中列出了 Hashtable 类中一些常用的方法：

方法名	描述
public virtual void Add(object key, object value)	向哈希表中添加一个带有指定的键和值的元素
public virtual void Clear()	从哈希表中移除所有的元素
public virtual bool ContainsKey(object key)	判断哈希表是否包含指定的键
public virtual bool ContainsValue(object value)	判断哈希表是否包含指定的值
public virtual void Remove(object key)	从哈希表中移除带有指定的键的元素

•SortedList 排序列表:

//SortedList 排序列表
// 存储一系列按照 键 进行排序的 键值对，可以通过 键/索引 访问这些 键值对
//如果使用 索引 访问，那么它就是 一个动态数组（ArrayList）
//如果使用 键 访问，那么它就是 一个哈希表（Hashtable）
// 集合中的各项总是按照键值排序的
SortedList sortedList = new SortedList();
sortedList.Add(6, "aaa");
sortedList.Add(2, "bbb");
// 可以通过键进行访问
Console.WriteLine(sortedList[6]);
Console.WriteLine(sortedList[2]);
//通过 索引 进行访问 值，排序列表 会自动 根据键 进行排序
Console.WriteLine(sortedList.GetByIndex(0));//bbb
Console.WriteLine(sortedList.GetByIndex(1));//aaa
//修改
sortedList[6] = "abc";
Console.WriteLine(sortedList.GetByIndex(1));//abc
Console.WriteLine(sortedList.Count);//2
Console.WriteLine(sortedList.Keys);
Console.WriteLine(sortedList.Values);
//方法
Console.WriteLine(sortedList.ContainsKey(6));//true
Console.WriteLine(sortedList.ContainsValue("aaa"));//False
// 变量名.Remove 根据 键 删除
sortedList.Remove(2);
// 变量名.RemoveAt 根据 索引 删除
sortedList.RemoveAt(1);
// 变量名.GetKey 根据 索引 获取指定位置 的键
Console.WriteLine(sortedList.GetKey(1));//6
// 变量名.GetByIndex 根据 索引 获取到指定位置 的值
Console.WriteLine(sortedList.GetByIndex(1));//abc

•堆(Heap)栈(Stack):

堆(Heap)栈(Stack) 类 表示一个 后进先出 的集合对象，当你的项目需要进行 先进后出 访问时，则可以使用 堆栈。

向堆栈中 添加 元素称之为 入栈 移除 称之为 出栈

// 声明一个堆栈
Stack stack = new Stack();
Stack stack1 = new Stack();
// 添加一个数据.Push
stack1.Push(1);
stack.Push("吴亦");
//栈不存在删除的概念 只有取的概念
// 取出一个数据 （只能取出最后一个）
stack.Pop();//取出吴
//栈无法查看指定位置的 元素
//只能查看栈顶的内容
stack.Peek();
//查看元素是否存在于栈中
if(stack.Contains("123"))
{ Console.WriteLine("存在123")}
// 清空堆栈
stack.Clear();
//将堆栈转化为数组
string[] s = stack.ToArray();
//遍历
//长度
Console.WriteLine(stack.Count);
//用foreach遍历
//而且遍历出来的顺序,也是从栈顶到栈底
foreach (var item in stack)
 { Console.WriteLine(stack); }
//栈不能直接使用for循环遍历
//将栈转换为object数组
//遍历出来的顺序,也是从栈顶到栈底
object[] array = stack.ToArray();
for(int i= 0;i0)
{
    object o = stack.Pop();
    Console.WriteLine(o);
}

•Queu列队:

//Queue是一个c#为我们封装好的类
//它的本质也是object[]数组，只是封装了特殊的存储规则
//Queue是队列存储容器
//队列是一种先进先出的数据结构
//先存入的数据先获取，后存入的数据后获取
//向队列 添加 元素我们称之为 入队，删除 称之为 出队
//声明一个队列
 Queue queue = new Queue();
 //入队  添加的意思
 queue.Enqueue("吴亦");
 queue.Enqueue("罗志");
 //队列不存在删除的概念 只有取的概念 取出先加入的对象
 //出队  取的意思
 queue.Dequeue();
 //查看队列同步元素但不会移除
 queue.Peek();
//查看元素是否存在于队列中
if(queue.Contains("吴亦"))
{ Console.WriteLine("存在吴亦凡")}
 //转换数组
 string[] q = queue.ToArray();
 //清空
 queue.Clear();
//遍历
//长度
Console.WriteLine(queue.Count);
//用foreach遍历
//而且遍历出来的顺序,也是从栈顶到栈底
foreach (var item in queue)
 { Console.WriteLine(queue); }
//将队列转换为object数组 遍历
object[] array = queue.ToArray();
for(int i= 0;i0)
{
    object o = queue.Pop();
    Console.WriteLine(o);
}