C#中List怎么用?List基础用法汇总

《C#中List怎么用？List基础用法汇总》

在C#编程中，List是.NET框架提供的动态数组集合，属于System.Collections.Generic命名空间。相较于传统数组，List具有动态扩容、类型安全、内置方法丰富等优势，是处理有序数据集合的常用工具。本文将从基础操作到高级技巧，系统梳理List的核心用法。

一、List的创建与初始化

创建List需要指定元素类型，可通过构造函数或集合初始化器完成。

// 创建空List
List numbers = new List();

// 创建带初始容量的List（避免多次扩容）
List names = new List(100);

// 使用集合初始化器
List prices = new List { 19.99, 29.99, 39.99 };

// 从数组转换
string[] fruits = { "Apple", "Banana", "Orange" };
List fruitList = new List(fruits);

注意事项：

• 必须指定泛型类型参数
• 初始容量设置可优化性能
• 支持从其他集合类型转换

二、基础元素操作

1. 添加元素

List letters = new List();
letters.Add('A');       // 添加单个元素
letters.AddRange(new[] {'B', 'C', 'D'}); // 添加多个元素

// 插入到指定位置
letters.Insert(1, 'X'); // 在索引1处插入

2. 访问元素

char first = letters[0];       // 通过索引访问
char last = letters[letters.Count - 1]; // 访问最后一个元素

// 安全访问（避免索引越界）
if (letters.Count > 2)
{
    char third = letters[2];
}

3. 修改元素

letters[0] = 'Z'; // 修改指定索引元素

4. 删除元素

letters.Remove('A');       // 删除第一个匹配项
letters.RemoveAt(0);       // 删除指定索引元素
letters.RemoveRange(1, 2); // 删除范围（从索引1开始，删除2个）
letters.Clear();           // 清空列表

三、常用属性与方法

1. 容量与计数

List data = new List(10);
Console.WriteLine(data.Capacity); // 10（当前容量）
Console.WriteLine(data.Count);    // 0（实际元素数）

// 手动调整容量
data.TrimExcess(); // 缩减容量到实际大小

2. 查找元素

List cities = new List { "NY", "LA", "CHI" };

// 存在性检查
bool hasLA = cities.Contains("LA");

// 查找索引
int index = cities.IndexOf("CHI"); // 返回2
int lastIndex = cities.LastIndexOf("A"); // 未找到返回-1

// 查找元素（使用谓词）
string longCity = cities.Find(c => c.Length > 2); // 返回"CHI"

3. 排序与反转

List nums = new List { 3, 1, 4, 2 };

// 升序排序
nums.Sort(); // 结果: [1, 2, 3, 4]

// 降序排序
nums.Sort((a, b) => b.CompareTo(a)); // 或使用Reverse()

// 自定义排序
List people = new List {
    new Person("Alice", 25),
    new Person("Bob", 20)
};
people.Sort((x, y) => x.Age.CompareTo(y.Age)); // 按Age升序

4. 转换操作

// 转换为数组
string[] cityArray = cities.ToArray();

// 转换为只读列表
IReadOnlyList readOnly = cities.AsReadOnly();

// 转换为其他集合
HashSet citySet = new HashSet(cities);

四、高级操作技巧

1. 批量操作

List source = new List { 1, 2, 3 };
List target = new List { 4, 5, 6 };

// 合并列表
target.AddRange(source); // [4,5,6,1,2,3]

// 使用Concat（LINQ方式）
var combined = source.Concat(target).ToList();

2. 线程安全操作

// 使用锁保护共享List
private List sharedList = new List();
private readonly object lockObj = new object();

void AddSafely(int value)
{
    lock (lockObj)
    {
        sharedList.Add(value);
    }
}

// 或使用并发集合（.NET 4.0+）
ConcurrentBag concurrentBag = new ConcurrentBag();
concurrentBag.Add(10);

3. 自定义比较器

public class LengthComparer : IComparer
{
    public int Compare(string x, string y)
    {
        return x.Length.CompareTo(y.Length);
    }
}

List words = new List { "apple", "banana", "kiwi" };
words.Sort(new LengthComparer()); // 按字符串长度排序

4. 分页处理

List allItems = Enumerable.Range(1, 100).ToList();
int pageSize = 10;
int pageNumber = 2;

var page = allItems
    .Skip((pageNumber - 1) * pageSize)
    .Take(pageSize)
    .ToList(); // 获取第2页数据（11-20）

五、性能优化建议

1. 预估容量：

// 知道大约需要1000个元素时
List optimized = new List(1000);

2. 避免频繁扩容：

• 每次扩容约增加当前容量50%
• 大量添加前设置足够Capacity

3. 选择合适的数据结构：

• 需要快速查找 → HashSet/Dictionary
• 需要保持插入顺序 → List
• 需要线程安全 → ConcurrentBag/Queue

4. 使用结构体（值类型）时注意装箱开销：

// 不好：频繁装箱
List

六、常见问题解决方案

1. 索引越界异常

List list = new List { 1, 2 };
try
{
    int value = list[3]; // 抛出ArgumentOutOfRangeException
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine($"错误: {ex.Message}");
}

// 安全访问模式
if (list.Count > 3)
{
    // 安全操作
}

2. 修改集合时的枚举异常

List names = new List { "A", "B" };
foreach (var name in names)
{
    if (name == "A")
    {
        names.Add("C"); // 抛出InvalidOperationException
    }
}

// 解决方案1：创建副本枚举
foreach (var name in names.ToList())
{
    // 安全操作
}

// 解决方案2：使用for循环
for (int i = 0; i 

3. 自定义对象比较

public class Product
{
    public string Id { get; set; }
    public decimal Price { get; set; }
}

List products = new List
{
    new Product { Id = "P1", Price = 10 },
    new Product { Id = "P2", Price = 20 }
};

// 方法1：实现IComparable
public class Product : IComparable
{
    public int CompareTo(Product other)
    {
        return Price.CompareTo(other.Price);
    }
}
products.Sort();

// 方法2：使用Lambda表达式
products.Sort((x, y) => x.Id.CompareTo(y.Id));

七、与数组的对比选择

特性	List	数组
容量	动态调整	固定大小
性能	稍慢（动态管理开销）	更快（直接内存访问）
功能	内置排序、查找等方法	需手动实现或使用Array类方法
适用场景	元素数量不确定或频繁增删	元素数量固定且已知

示例：数组与List的互转

// 数组转List
int[] arr = { 1, 2, 3 };
List listFromArr = new List(arr);

// List转数组
int[] arrFromList = listFromArr.ToArray();

八、实际应用案例

案例1：数据处理管道

List rawData = GetRawData(); // 假设获取原始数据

// 过滤空值
var filtered = rawData.Where(d => !string.IsNullOrEmpty(d)).ToList();

// 转换大小写
var processed = filtered.Select(d => d.ToUpper()).ToList();

// 去重排序
var result = processed.Distinct().OrderBy(d => d).ToList();

案例2：分页实现

public class PaginatedResult
{
    public List Items { get; set; }
    public int TotalCount { get; set; }
    public int PageSize { get; set; }
    public int CurrentPage { get; set; }
}

public PaginatedResult GetPaged(List source, int page, int size)
{
    return new PaginatedResult
    {
        Items = source.Skip((page - 1) * size).Take(size).ToList(),
        TotalCount = source.Count,
        PageSize = size,
        CurrentPage = page
    };
}

案例3：缓存实现

public class SimpleCache
{
    private readonly List> _cache = new List>();
    
    public void Add(TKey key, TValue value)
    {
        _cache.Add(new KeyValuePair(key, value));
    }
    
    public bool TryGetValue(TKey key, out TValue value)
    {
        var item = _cache.FirstOrDefault(x => Equals(x.Key, key));
        if (item.Key != null)
        {
            value = item.Value;
            return true;
        }
        value = default;
        return false;
    }
    
    public void ClearExpired(DateTime expiryThreshold)
    {
        // 假设KeyValuePair存储了过期时间
        _cache.RemoveAll(x => x.Value is CacheItem ci && ci.Expiry 

关键词：C#、List、动态数组、集合操作、泛型集合、元素管理、性能优化、线程安全、LINQ集成、数据结构选择

简介：本文全面介绍了C#中List集合的用法，涵盖基础操作（创建、增删改查）、常用方法（排序、查找、转换）、高级技巧（批量操作、线程安全、自定义比较）、性能优化建议及常见问题解决方案，通过实际案例展示List在数据处理、分页、缓存等场景的应用，帮助开发者高效使用这一核心集合类型。