C# Lambda 表达式与集合基础笔记

lambd表达式概念

lambd表达式，可以让我们定义一个变量接收一个函数，主要是作为另外一个函数的参数进行使用。

C# 的 Lambda 表达式本质是 “匿名函数的简洁写法”，用于快速创建委托 / 表达式树实例，变量与函数体间用=>（Lambda 运算符）分隔；而 “箭头函数”（如 JavaScript 的()=>{}）是独立的函数语法 ，C# 中并无此概念 ——C# 的=>仅用于 Lambda 表达式，而非定义独立函数，这是关键区别。

定义lambda表达式

方法的组成： 参数列表、返回值 、方法名 方法体

1.使用Func关键字接收有返回值的lambda表达式

Func<int,int ,int> f1 = (a, b) => { return a + b; }; Console.WriteLine(f1(10,20));// 可以通过变量名调用函数

Func<参数类型,参数类型，返回值类型> f1 = (a,b)=>{return a+b}
可以接受有返回值的lambda表达式 参数个数没有限制、返回值的类型也是没有限制

Func<> 方法类型、函数类型
第一个类型 是参数1的类型
第二个类型 是参数2的类型
第三个类型 是返回值的类型
f1 变量名
(a, b) 参数类别 不用写类型，多个参数时候加()
=> 表达式
{}方法体 有返回值的添加return 关键字。

2使用Action关键字接收无返回值的lambda表达式

定义一个字符串参数 无返回值的lambda表达式
如果一个参数可以把()不写
如果函数体只有一句可以把{}省掉

Action<string> f2 = (a) => Console.WriteLine(a); //只能接收无返回值的lambda表达式 f2("hell world");

3 使用Predicate<>关键字接收返回值为bool类型的lambda表达式

只能接收返回值为bool类型的lambda表达式

Predicate<int> f3 = a=> a %2==0; Console.WriteLine(f3(3));//false Func<int,bool> f4 = a=> a%3==0; Console.WriteLine(f4(9));//true

lambda具体的使用场景：最为另外一个函数参数进行使用，数组的查询方法当中使用

int[] ints = { 1, 2, 3, 4,6,9 }; Console.WriteLine(Array.Find(ints, a => a % 2 == 0));//2 int[] ss = Array.FindAll(ints,v=>v%3==0);//找到所有的数组 // 第一种遍历数组 for (int i = 0; i < ss.Length; i++) { Console.WriteLine(ss[i]+"-------"); } //第二种遍历数组 foreach (var item in ss) { Console.WriteLine(item+"+++++++"); } // 第三种遍历数组 Array.ForEach(ss, v => Console.WriteLine(v + "?????")); //where 找到所有满足条件的元素 foreach (var item in ints.Where(v => { return v % 3 == 0; })) { Console.WriteLine(item); } Console.ReadKey();

ArrayList动态数组

ArrayList动态数组概念：

动态数组一个不固定长度的数组集合，并且可以存储不同类型的元素，例如一个arrayList对象可以存储整型、字符串、对象、数组等，

但是int[]这种数组一旦创建好之后 不能后续添加元素，也就是长度是固定，并且一个数组对象只能存储一种类型的元素

ArrayList 弊端：取出元素是一个object 必须对其在进行类型转换.

1.ArrayList动态数组的使用

//1 创建一个arrayList对象 int[] ints = new int[] { 1, 2, 3 }; People p1 = new People() { Name="zs"}; ArrayList arr = new ArrayList() { 1,2,3,"坤拳",true,ints,p1}; //初始化添加元素 //2 取出元素 通过索引值取元素 arr[1] //int aa = arr[0]; //数组取出的元素是object类型，如果想转成其他类型 必须强制转换 Console.WriteLine( Convert.ToInt16(arr[1]));

List<T>泛型集合

list集合是最常用的动态数组，支持灵活的增删改查，也是 Lambda 表达式最常结合使用的容器之一。
List<T> 是泛型类，T 为元素类型（如 int、string、自定义类），支持动态扩容（无需手动指定长度）。

List方法和ArrayList很像 区别在于list可以指定类型进行存储，存储同一种类型数据 ，取出时候不用强制转换，保证数据类型安全

List集合的方法

1. 添加元素

List<int> list1 = new List<int>(); //创建集合对象 list1.Add(1);//添加元素 list1.AddRange(new int[] {9,10,11}); //添加多个

2. 删除

List<int> list1 = new List<int>(){ 1,2,3,5,4};; //创建集合对象 list1.Remove(5);//删除指定元素 list1.RemoveAt(list1.Count-1);//删除指定位置的元素 list1.RemoveAll(v => v % 3 == 0);//删除满足条件所有的元素

3.修改

List<int> list1 = new List<int>() { 1,23,5,4}; //创建集合对象 list1[0] = 20;// 对集合的第一个元素重新赋值

4.插入数据

List<int> list1 = new List<int>() { 1,23,5,4}; //创建集合对象 list1.Insert(1, 10);//在索引值为1的地方插入 10

5. IndexOf() 获取元素的索引值

List<int> list1 = new List<int>() { 1,23,5,4}; Console.WriteLine(list1.IndexOf(23));

6. Clear()清空集合

List<int> list1 = new List<int>() { 1,23,5,4}; list1.Clear(); 清空集合

7.Any() 有一个满足条件就为true

List<int> list1 = new List<int>() { 1,23,5,4}; Console.WriteLine(list1.Any(v => v > 3));

8.Average() 求序列中元素的平均值

List<int> list1 = new List<int>() { 1,23,5,4}; Console.WriteLine(list1.Average());

9.Concat() 拼接俩个数组，返回的是一个新数组

List<int> list1 = new List<int>() { 1,23,5,4}; List<int> list2= list1.Concat(new int[] {36}).ToList(); //.ToList() 转成list类型 //返回值是 IEnumerable<>可枚举接口类型 , 需要转成list

10Contains() 判断数组是否包含 某个元素，，返回值bool 类型

List<int> list1 = new List<int>() { 1,23,5,4}; Console.WriteLine(list1.Contains(2));//数组是否包含2

11 Sum() 求和

List<int> list1 = new List<int>() { 1,23,5,4}; Console.WriteLine(list1.Sum());

12 Skip() 跳过自定的个数，返回剩余的

List<int> list1 = new List<int>() { 1,23,5,4}; //创建集合对象 int[] ss = list1.Skip(1).ToArray();

13 Max() 找出序列元素最大值

List<int> list1 = new List<int>() { 1,23,5,4}; //创建集合对象 Console.WriteLine(list1.Max());

14.Enumerable.Join() 方法：核心是基于指定的关联条件，将两个集合进行内连接 ,最终生成对象类型的新序列

class People { public int Num1 { get; set; } public int Num2 { get; set; } }

List<int> list1 = new List<int>() { 1,23,5,4}; //创建集合对象 int[] nums = new int[] { 1, 2, 4 }; var result = list1.Join(nums , x => x, y => y * 10, (x, y) => new People() { Num1 = x, Num2 = y } ); foreach (var item in result) { Console.WriteLine(item.Num1 + "-----" + item.Num2); } Console.ReadKey(); //定义一个集合{ 1,23,5,4} 一个数组 nums { 1, 2, 4 } //x => x, 针对list1集合里面的元素进行操作，不做任何计算 //y => y * 10 , 针对nums里面元素进行*10的操作 变成了{10,20,40} //(x,y)=>new People(){ Num1=x,Num2=y } 对变化之后的xy添加到People的Num1和Num2属性上 //方法的结果一个集合，list1 的 20 与 nums 的 2*10 对应上， 把对应关返回了 //也就是20 ----- 2作为匹配结果 // 10 ----1 也是匹配上