C#List泛型集合

一、List<T> 核心概念（泛型集合）

1. 语法说明

List<T> 是 泛型动态集合

• T：占位符，代表任意指定类型

• List<int>：只能存整型

• List<string>：只能存字符串

特点：类型安全、动态扩容、无装箱拆箱、效率高

2. 创建对象两种方式

// 1. 空集合，后续动态添加
List<int> list = new List<int>();

// 2. 初始化带元素的集合
List<string> list1 = new List<string> { "李张三", "李四" };

3. 获取集合元素个数

Console.WriteLine(list1.Count); 

区别：数组是 Length ，集合是 Count

二、List 基础增删改查（全套方法）

1. 添加元素

• Add()：添加单个元素

• AddRange()：批量添加集合/数组

list1.Add("1");
list1.AddRange(new List<string> { "王五" });

2. 删除元素（四种删除方式）

// 1. 删除匹配的第一个元素
list1.Remove("1");

// 2. 删除指定索引位置元素
list1.RemoveAt(0);

// 3. 条件删除（高阶方法）
// 返回值：成功删除的元素个数
Console.WriteLine(list1.RemoveAll(v => v.StartsWith("李")));

RemoveAll 重点：根据 Lambda 条件批量删除，返回删除数量

3. 修改元素

通过索引直接覆盖赋值（和数组一致）

list1[2] = "焦恩俊";

4. 插入元素

// 在指定索引位置插入元素
list1.Insert(4, "何家劲");

5. 查询元素 / 索引

// 获取指定元素的索引
list1.IndexOf("1");

// 判断是否包含某个元素，返回 bool
list1.Contains("李四");

三、List 高阶方法 和 数组高阶方法区别（必考）

1. 调用方式区别

• 数组 ：静态方法 → Array.方法名(数组,条件)

• List集合 ：实例方法 → 集合对象.方法名(条件)

2. 同款高阶方法（和数组完全通用）

• Find、FindAll、FindIndex、Exists、TrueForAll、ForEach

3. ForEach 遍历高阶写法（企业常用）

// 一行代码遍历打印所有元素
list1.ForEach(x => Console.WriteLine(x));

四、集合遍历方式

// foreach 遍历
foreach (var i in list1)
{
    Console.WriteLine(i + "-------");
}

五、List<T> VS ArrayList（终极对比）

对比项	ArrayList	List<T>（推荐）
类型安全	不安全，任意 object 类型	类型安全，固定泛型类型
装箱拆箱	频繁发生，效率低	无装箱拆箱，效率高
通用性	老旧技术，已淘汰	项目开发 百分百使用
读写速度	慢	快

---

六、List 常用 LINQ 高阶方法（补充）

LINQ 是 C# 集成的查询语法，可配合 Lambda 快速实现集合筛选、排序、映射、去重等操作，仅支持 List、数组 等可枚举集合，开发使用率极高。

使用前提：需引入命名空间 using System.Linq;

1. Where 条件筛选（核心最常用）

根据自定义条件过滤元素，返回所有满足条件的元素，结果需通过 ToList() 转为 List 集合

List<int> nums = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };
// 筛选所有偶数
List<int> evenList = nums.Where(x => x % 2 == 0).ToList();
// 筛选大于4的数
List<int> bigList = nums.Where(x => x > 4).ToList();

2. Select 映射/转换

遍历集合，对每个元素进行加工、转换、投影，生成新数据（可改类型、改数值）

List<int> nums = new List<int> { 1, 2, 3 };
// 每个元素翻倍
List<int> doubleList = nums.Select(x => x * 2).ToList();

// 数值转字符串
List<string> strList = nums.Select(x => x + "号").ToList();

3. OrderBy / OrderByDescending 排序

• OrderBy：升序排序（从小到大）

• OrderByDescending：降序排序（从大到小）

List<int> nums = new List<int> { 5, 2, 9, 1, 3 };
// 升序
List<int> ascList = nums.OrderBy(x => x).ToList();
// 降序
List<int> descList = nums.OrderByDescending(x => x).ToList();

4. Distinct 去重

自动剔除集合中重复元素，返回去重后的新集合

List<int> nums = new List<int> { 1, 2, 2, 3, 3, 3 };
List<int> distinctList = nums.Distinct().ToList();
// 结果：1,2,3

5. First / FirstOrDefault 取首个元素

• First()：获取第一个满足条件的元素，无匹配直接报错

• FirstOrDefault()：无匹配不报错，返回对应类型默认值（推荐使用）

List<int> nums = new List<int> { 1, 2, 3, 4 };
int first = nums.First(x => x > 2); // 3
int def = nums.FirstOrDefault(x => x > 10); // 无匹配，返回int默认值0

6. Any / All 条件判断（布尔返回）

• Any()：存在一个满足条件 → true，全部不满足 → false

• All()：所有元素都满足条件 → true，有一个不满足 → false

List<int> nums = new List<int> { 1, 2, 3, 4 };
bool hasEven = nums.Any(x => x % 2 == 0); // true（存在偶数）
bool allBig = nums.All(x => x > 0); // true（全部大于0）

7. Count 条件计数

重载方法，可根据 Lambda 条件统计满足条件的元素个数（区别于原生无参Count）

List<int> nums = new List<int> { 1, 2, 3, 4, 5, 6 };
int evenCount = nums.Count(x => x % 2 == 0); // 统计偶数个数：3

8. Skip / Take 分页截取

• Skip(n)：跳过前 n 个元素

• Take(n)：截取后续 n 个元素

List<int> nums = new List<int> { 1, 2, 3, 4, 5, 6 };
// 跳过前2个，取3个元素 → 结果：3,4,5
List<int> pageList = nums.Skip(2).Take(3).ToList();

LINQ 核心口诀（必背）

• Where 筛数据、Select 做转换

• Order 排顺序、Distinct 去重复

• First 取首个、Any/All 做判断

• Count 计数量、Skip/Take 做分页

• 所有LINQ查询结果，必须 ToList() 转回List集合

---

七、全套方法速查表（背诵版）

• 新增：Add()、AddRange()、Insert()

• 删除：Remove()、RemoveAt()、RemoveAll(条件)

• 修改：集合索引 = 新值

• 查询：IndexOf()、Contains()

• 遍历：foreach / ForEach(lambda)

• 统计个数：Count

• LINQ高频：Where、Select、OrderBy、Distinct、FirstOrDefault、Any、All、Skip、Take

---

八、核心总结

1. List<T> 是类型安全的动态集合，彻底解决 ArrayList 装箱拆箱、类型混乱问题

2. 数组调用静态方法，List 调用实例方法

3. RemoveAll 支持 Lambda 条件删除，返回删除元素个数

4. 集合元素个数用 Count，数组长度用 Length

5. 开发中 永远用 List<T>，不用 ArrayList

6. LINQ 是 List 核心拓展能力，极简代码实现复杂筛选、排序、分页，是项目开发主流写法