11.C# —— 数组属性、高级方法与 Lambda 表达式

一、数组的基础属性与常用静态方法

[1. 数组核心属性](#1. 数组核心属性)

[2. Array 静态常用方法](#2. Array 静态常用方法)

[2.1 Array.Clear 清空数组元素](#2.1 Array.Clear 清空数组元素)

[2.2 Array.Copy 数组拷贝](#2.2 Array.Copy 数组拷贝)

[2.3 元素索引查询](#2.3 元素索引查询)

完整示例代码

[二、数组高级方法（条件查询 / 遍历）](#二、数组高级方法（条件查询 / 遍历）)

[1. 核心概念铺垫](#1. 核心概念铺垫)

[2. 数组高级方法大全](#2. 数组高级方法大全)

[3. 数组实例扩展方法（LINQ）](#3. 数组实例扩展方法（LINQ）)

完整示例代码

[三、Lambda 表达式（匿名函数）](#三、Lambda 表达式（匿名函数）)

[1. 为什么需要 Lambda？](#1. 为什么需要 Lambda？)

[2. Lambda 基础语法](#2. Lambda 基础语法)

[3. C# 三大委托（搭配 Lambda 使用）](# 三大委托（搭配 Lambda 使用）)

[4. Lambda 实战（结合数组）](#4. Lambda 实战（结合数组）)

[4.1 基础用法演示](#4.1 基础用法演示)

[4.2 三大委托 + Lambda 完整总结](#4.2 三大委托 + Lambda 完整总结)

四、知识点总结

[1. 数组属性回顾](#1. 数组属性回顾)

[2. Array 静态方法分类](#2. Array 静态方法分类)

[3. LINQ 数组实例方法](#3. LINQ 数组实例方法)

[4. Lambda 核心要点](#4. Lambda 核心要点)

一、数组的基础属性与常用静态方法

1. 数组核心属性

数组继承自 Array 类，自带三个常用实例属性：

Length ：获取数组元素总个数（int 类型）
Rank ：获取数组维度数，一维数组固定为 1
LongLength：超大数组专用，返回 long 类型的元素总数

2. Array 静态常用方法

2.1 Array.Clear 清空数组元素

作用：将数组指定区间元素重置为对应类型默认值（int → 0、string → null）语法：

cs 复制代码

Array.Clear(数组, 起始索引, 清空长度);

2.2 Array.Copy 数组拷贝

实现数组元素复制，分两种重载：

基础重载：Array.Copy(源数组, 目标数组, 复制长度)
精准拷贝：Array.Copy(源数组, 源起始索引, 目标数组, 目标起始索引, 复制长度)

重点特性：

值类型数组：Copy 是浅拷贝，修改原数组不会影响新数组

引用类型数组：拷贝后元素指向同一地址，修改会互相影响

2.3 元素索引查询

Array.IndexOf(数组, 目标值)：从前向后 查找第一个匹配元素的索引，无匹配返回 -1
Array.LastIndexOf(数组, 目标值)：从后向前查找第一个匹配元素的索引
重载扩展：可指定查询起始位置 、查询范围长度

完整示例代码

cs 复制代码

using System;

namespace _2数组的属性和方法
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int[] nums = { 1, 2, 3, 4, 5, 6 };
            // 数组属性
            Console.WriteLine("元素总数 Length：" + nums.Length);      // 6
            Console.WriteLine("数组维度 Rank：" + nums.Rank);        // 1
            Console.WriteLine("长整型总数 LongLength：" + nums.LongLength); // 6

            // 1. Clear 清空指定区间元素
            Array.Clear(nums, 1, 3); // 从索引1开始，清空3个元素
            Console.WriteLine("Clear 后数组：" + string.Join("-", nums)); // 1-0-0-0-5-6

            // 2. Copy 数组拷贝
            int[] nums1 = { 1, 2, 3, 4 };
            int[] nums2 = new int[nums1.Length];
            Array.Copy(nums1, nums2, 4);
            nums1[0] = 100; // 值类型，修改原数组不影响副本
            Console.WriteLine("Copy 后目标数组：" + string.Join("-", nums2)); // 1-2-3-4

            // 3. 索引查询
            int[] nums3 = { 1, 2, 3, 4, 3 };
            Console.WriteLine("IndexOf 3：" + Array.IndexOf(nums3, 3));      // 2
            Console.WriteLine("LastIndexOf 3：" + Array.LastIndexOf(nums3, 3)); // 4
            Console.WriteLine("指定起始位置查询：" + Array.IndexOf(nums3, 3, 3)); // 4
        }
    }
}

二、数组高级方法（条件查询 / 遍历）

1. 核心概念铺垫

高阶函数：参数本身也是一个函数的方法
回调函数：当作参数传递给高阶函数的函数（C# 中本质是委托）

Array 提供一组按条件筛选的高级静态方法，不再局限于固定值查询，支持自定义匹配规则。

2. 数组高级方法大全

方法	作用	返回值
`Array.Find`	查找第一个满足条件的元素	数组元素类型
`Array.FindLast`	从后查找第一个满足条件的元素	数组元素类型
`Array.FindAll`	查找所有满足条件的元素	同类型新数组
`Array.FindIndex`	查找第一个满足条件元素的索引	int
`Array.FindLastIndex`	从后查找第一个满足条件元素的索引	int
`Array.ForEach`	遍历数组，执行自定义逻辑	无返回值
`Array.TrueForAll`	判断所有元素是否都满足条件	bool
`Array.Exists`	判断是否存在至少一个满足条件的元素	bool

3. 数组实例扩展方法（LINQ）

需要引用命名空间 using System.Linq;，数组实例直接调用：

All()：等价 TrueForAll，全部满足条件返回 true
Any()：等价 Exists，存在一个满足条件返回 true
GetValue(索引)：获取指定索引元素
SetValue(值, 索引)：修改指定索引元素
Count()：等价 Length，获取元素个数

完整示例代码

cs 复制代码

using System;
using System.Linq;

namespace _3数组的高级方法
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int[] ages = { 20, 10, 30, 40, 50, 19, 21 };

            // 1. Find 查找第一个满足条件元素
            Console.WriteLine("小于18的第一个元素：" + Array.Find(ages, FindSmall18)); // 10
            Console.WriteLine("偶数第一个元素：" + Array.Find(ages, FindEven));       // 20
            Console.WriteLine("同时被3、5整除的元素：" + Array.Find(ages, Find35));    // 30

            // 2. FindLast 从后查找
            Console.WriteLine("从后找3、5公倍数：" + Array.FindLast(ages, Find35));    // 30

            // 3. FindAll 查找所有满足条件元素
            int[] oddArr = Array.FindAll(ages, FindOdd);
            Console.WriteLine("所有奇数：" + string.Join("-", oddArr)); // 19-21

            // 4. 查找索引
            Console.WriteLine("第一个偶数索引：" + Array.FindIndex(ages, FindEven));     // 0
            Console.WriteLine("最后一个偶数索引：" + Array.FindLastIndex(ages, FindEven));// 4

            // 5. ForEach 遍历
            Console.WriteLine("ForEach 遍历结果：");
            Array.ForEach(ages, F1);

            // 6. TrueForAll / Exists
            Console.WriteLine("数组全是奇数？" + Array.TrueForAll(oddArr, FindOdd)); // True
            Console.WriteLine("存在3、5公倍数？" + Array.Exists(ages, Find35));      // True

            // 7. LINQ 实例方法
            string[] strs = { "张三", "李四" };
            Console.WriteLine("元素个数：" + strs.Count());
            Console.WriteLine("存在长度为2的字符串？" + strs.Any(F2));

            // 8. GetValue / SetValue 读写元素
            strs.SetValue("郑爽", 0);
            Console.WriteLine("修改后元素：" + strs.GetValue(0));
        }

        // 匹配规则方法
        public static bool FindSmall18(int v) => v < 18;
        public static bool FindEven(int v) => v % 2 == 0;
        public static bool FindOdd(int v) => v % 2 != 0;
        public static bool Find35(int v) => v % 3 == 0 && v % 5 == 0;
        public static void F1(int v) => Console.WriteLine(v + " +++++++");
        public static bool F2(string v) => v.Length == 2;
    }
}

三、Lambda 表达式（匿名函数）

1. 为什么需要 Lambda？

数组高级方法需要传入回调函数 ，单独定义独立方法代码冗余、可读性差。 Lambda 表达式 = 匿名函数，可以直接内联编写逻辑，简化代码。

2. Lambda 基础语法

完整语法：

cs 复制代码

(参数1, 参数2, ...) => { 函数体 };

语法简化规则：

参数：可省略参数类型；单个参数可省略小括号
函数体 ：单行代码可省略 {} 和 return
仅能作为高阶函数参数 或 委托变量 接收使用

3. C# 三大委托（搭配 Lambda 使用）

专门用来接收 Lambda 表达式的系统内置委托，也是数组高级方法的底层参数类型：

Func<T> ：有返回值的函数，最后一个泛型参数为返回值类型，前面全是参数类型
Action<T>：无返回值的函数，只有参数类型
Predicate<T> ：固定返回 bool、且只能有一个参数，数组条件查询专用

4. Lambda 实战（结合数组）

4.1 基础用法演示

cs 复制代码

using System;
using System.Linq;

namespace _4Lambda表达式
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int[] ages = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

            // 1. 原生独立方法（繁琐）
            Console.WriteLine(Array.Find(ages, F9));

            // 2. Lambda 直接内联（推荐写法）
            Console.WriteLine("第一个奇数：" + Array.Find(ages, v => v % 2 != 0));

            // 3. 查询字符串数组
            string[] strs = { "吴亦凡", "罗志祥", "郑爽", "东北雨姐" };
            Console.WriteLine("长度为2的字符串：" + Array.Find(strs, v => v.Length == 2));
            Console.WriteLine("以吴开头：" + Array.Find(strs, v => v.StartsWith("吴")));
            Console.WriteLine("以姐结尾且长度4：" + Array.Find(strs, v => v.EndsWith("姐") && v.Length == 4));

            // 4. LINQ Where 筛选 + 转数组
            string[] filterArr = strs.Where(a => a.Length == 3).ToArray();
            Console.WriteLine("长度为3的元素：" + string.Join("-", filterArr));
        }

        public static bool F9(int v) => v % 2 == 0;
    }
}

4.2 三大委托 + Lambda 完整总结

cs 复制代码

using System;

namespace _5总结lambda表达式三种写法
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int[] ages = { 3, 5, 7 };

            // 1. Func<>：有返回值
            Func<int, bool> IsPrime = a =>
            {
                bool flag = true;
                for (int i = 2; i < a; i++)
                {
                    if (a % i == 0)
                    {
                        flag = false;
                        break;
                    }
                }
                return flag;
            };
            Console.WriteLine("是否全是素数：" + ages.All(IsPrime)); // True

            // 2. Action<>：无返回值
            Action<int> PrintEven = a =>
            {
                if (a % 2 == 0) Console.WriteLine("偶数：" + a);
            };
            int[] ages1 = { 3, 5, 7, 4 };
            Array.ForEach(ages1, PrintEven);

            // 3. Predicate<>：单参数、返回bool（数组查询专用）
            Predicate<int> Big25 = a => a * a > 25;
            int[] ages2 = { 3, 5, 7, 4, 8 };
            int[] result = Array.FindAll(ages2, Big25);
            Console.WriteLine("平方大于25的元素：" + string.Join("-", result));
        }
    }
}

四、知识点总结

1. 数组属性回顾

Length / LongLength：元素数量
Rank：数组维度

2. Array 静态方法分类

重置 / 拷贝：Clear、Copy
精准索引查询：IndexOf、LastIndexOf
条件查询：Find / FindAll / FindIndex / Exists / TrueForAll
遍历：ForEach

3. LINQ 数组实例方法

All()、Any()、Count()、GetValue()、SetValue()

4. Lambda 核心要点

本质：匿名函数，简化回调代码
语法：(参数) => 逻辑，支持多层简化
三大配套委托：
- Func：有返回值
- Action：无返回值
- Predicate：单参数、返回 bool（数组查询首选）
最佳实践：数组条件查询、LINQ 筛选优先使用 Lambda 内联写法