一、引言
在.NET开发中，List<T> 是我们经常会用到的一个集合类型。它就像是一个功能强大的收纳盒，可以装下各种类型的东西（也就是各种类型的对象），而且还能根据我们的需求动态地调整大小。今天咱们就来深入剖析一下 List<T> 的底层源码，主要看看它的动态扩容机制、数组拷贝原理，再一起探讨探讨它可能存在的性能瓶颈以及相应的优化方案。
二、动态扩容机制
2.1 基本原理
List<T> 本质上是基于数组实现的。数组有个特点，就是一旦创建，它的大小就固定了。但是 List<T> 可以动态地增加容量，这是怎么做到的呢？其实，当我们往 List<T> 里添加元素的时候，如果当前的容量不够了，List<T> 就会创建一个新的、更大的数组，然后把原来数组里的元素都复制到新数组里，最后把新元素添加进去。
2.2 示例代码
下面我们通过一个简单的 C# 示例来看看动态扩容是怎么发生的：
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// 创建一个初始容量为 2 的 List<int>
List<int> list = new List<int>(2);
// 打印初始容量
Console.WriteLine($"初始容量: {list.Capacity}");
// 添加元素
for (int i = 0; i < 5; i++)
{
list.Add(i);
// 每次添加元素后打印当前容量
Console.WriteLine($"添加元素 {i} 后，容量: {list.Capacity}");
}
}
}
2.3 代码解释
在这个示例中，我们首先创建了一个初始容量为 2 的 List<int>。然后通过一个循环往里面添加 5 个元素。每次添加元素后，我们都打印出当前的容量。运行这个程序，你会看到容量会随着元素的添加而动态增加。
2.4 扩容策略
List<T> 的扩容策略是每次容量不够时，将容量扩大为原来的 2 倍。例如，初始容量是 2，当添加第 3 个元素时，容量就会扩大到 4；当添加第 5 个元素时，容量会扩大到 8。
三、数组拷贝原理
3.1 拷贝的必要性
在动态扩容时，我们需要把原来数组里的元素复制到新数组里。这是因为原来的数组空间不够了，我们需要一个更大的数组来容纳更多的元素。
3.2 底层实现
在.NET 中，数组拷贝主要是通过 Array.Copy 方法来实现的。这个方法可以高效地将一个数组的元素复制到另一个数组中。
3.3 示例代码
using System;
class Program
{
static void Main()
{
// 创建一个包含 3 个元素的数组
int[] sourceArray = { 1, 2, 3 };
// 创建一个容量为 6 的新数组
int[] destinationArray = new int[6];
// 将 sourceArray 中的元素复制到 destinationArray 中
Array.Copy(sourceArray, destinationArray, sourceArray.Length);
// 打印复制后的数组
for (int i = 0; i < destinationArray.Length; i++)
{
Console.WriteLine($"destinationArray[{i}] = {destinationArray[i]}");
}
}
}
3.4 代码解释
在这个示例中，我们创建了一个包含 3 个元素的源数组 sourceArray 和一个容量为 6 的目标数组 destinationArray。然后使用 Array.Copy 方法将源数组的元素复制到目标数组中。最后，我们打印出目标数组的元素，验证复制是否成功。
四、性能瓶颈分析
4.1 频繁扩容导致的性能问题
由于 List<T> 每次扩容都需要创建新数组并进行数组拷贝，当元素数量较多且频繁扩容时，会消耗大量的内存和 CPU 资源。例如，在一个循环中不断往 List<T> 里添加元素，每次容量不够时都会触发扩容操作，这会严重影响性能。
4.2 示例代码
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
List<int> list = new List<int>();
// 记录开始时间
DateTime startTime = DateTime.Now;
for (int i = 0; i < 100000; i++)
{
list.Add(i);
}
// 记录结束时间
DateTime endTime = DateTime.Now;
// 计算耗时
TimeSpan elapsedTime = endTime - startTime;
Console.WriteLine($"添加 100000 个元素耗时: {elapsedTime.TotalMilliseconds} 毫秒");
}
}
4.3 代码解释
在这个示例中，我们创建了一个空的 List<int>，然后通过一个循环往里面添加 100000 个元素。在添加元素前后分别记录时间，计算出添加元素所花费的时间。由于频繁扩容，这个过程会比较耗时。
五、性能瓶颈优化方案
5.1 预估容量并指定初始容量
在创建 List<T> 时，如果我们能预估元素的数量，就可以指定初始容量，避免频繁扩容。
5.2 示例代码
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// 预估元素数量为 100000，指定初始容量
List<int> list = new List<int>(100000);
DateTime startTime = DateTime.Now;
for (int i = 0; i < 100000; i++)
{
list.Add(i);
}
DateTime endTime = DateTime.Now;
TimeSpan elapsedTime = endTime - startTime;
Console.WriteLine($"指定初始容量后，添加 100000 个元素耗时: {elapsedTime.TotalMilliseconds} 毫秒");
}
}
5.3 代码解释
在这个示例中，我们创建 List<int> 时指定了初始容量为 100000。然后同样往里面添加 100000 个元素。由于初始容量足够，不会触发扩容操作，所以添加元素的速度会快很多。
5.4 使用 List<T>.Capacity 属性手动调整容量
如果在程序运行过程中，我们知道元素数量不会再增加了，可以使用 List<T>.Capacity 属性将容量调整为实际元素数量，这样可以释放多余的内存。
5.5 示例代码
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
List<int> list = new List<int>(100);
for (int i = 0; i < 10; i++)
{
list.Add(i);
}
// 手动调整容量为实际元素数量
list.Capacity = list.Count;
Console.WriteLine($"调整容量后，容量: {list.Capacity}");
}
}
5.6 代码解释
在这个示例中，我们创建了一个初始容量为 100 的 List<int>，然后往里面添加 10 个元素。接着使用 list.Capacity = list.Count 将容量调整为实际元素数量。最后打印出调整后的容量。
六、应用场景
List<T> 适用于需要动态添加和访问元素的场景，例如：
- 数据收集：在程序运行过程中，需要不断收集数据，并且数据的数量不确定。可以使用
List<T>来存储这些数据。 - 数据处理：在对数据进行处理时，可能需要动态地添加或删除元素。
List<T>提供了方便的方法来实现这些操作。
七、技术优缺点
7.1 优点
- 动态扩容：可以根据需要动态调整容量，方便存储不同数量的元素。
- 使用方便：提供了丰富的方法，如
Add、Remove、IndexOf等，便于对元素进行操作。
7.2 缺点
- 频繁扩容性能问题：如前面所述，频繁扩容会消耗大量的内存和 CPU 资源。
- 插入和删除效率低：在
List<T>中间插入或删除元素时，需要移动后续的元素，效率较低。
八、注意事项
- 预估容量：在创建
List<T>时，尽量预估元素的数量并指定初始容量，避免频繁扩容。 - 内存管理：如果元素数量不再增加，及时调整容量，释放多余的内存。
九、文章总结
通过对 .NET List<T> 底层源码的分析，我们了解了它的动态扩容机制、数组拷贝原理以及可能存在的性能瓶颈。动态扩容机制使得 List<T> 可以根据需要动态调整容量，但频繁扩容会导致性能问题。数组拷贝是扩容过程中的关键操作，通过 Array.Copy 方法实现。为了优化性能，我们可以预估容量并指定初始容量，以及在合适的时候手动调整容量。在使用 List<T> 时，我们要根据具体的应用场景，权衡其优缺点，合理使用这个强大的集合类型。
评论