假设你需要有一个整数列表/数组，你需要频繁迭代，我的意思是非常频繁。原因可能各不相同，但可以说这是在一个大容量处理的最内部循环的核心。
通常情况下，人们会选择使用列表(List)，因为它们在大小上具有灵活性。最重要的是，msdn文档声称列表在内部使用数组，并且应该执行得一样快(快速查看Reflector证实了这一点)。尽管如此，还是有一些开销。
有人测量过吗?在一个列表中迭代6M次是否与数组相同?
当前回答
很容易测量…
在少量的紧循环处理代码中，我知道长度是固定的，我使用数组来进行额外的微小优化;如果你使用索引器/ for表单，数组可以稍微快一点——但是IIRC认为这取决于数组中数据的类型。但除非你需要进行微观优化，否则尽量保持简单，使用List<T>等。
当然，这只适用于读取所有数据的情况;对于基于键的查找，字典会更快。
下面是我使用“int”的结果(第二个数字是一个校验和，以验证它们都做了相同的工作):
(修改bug)
List/for: 1971ms (589725196)
Array/for: 1864ms (589725196)
List/foreach: 3054ms (589725196)
Array/foreach: 1860ms (589725196)
基于试验台:
using System;
using System.Collections.Generic;
using System.Diagnostics;
static class Program
{
static void Main()
{
List<int> list = new List<int>(6000000);
Random rand = new Random(12345);
for (int i = 0; i < 6000000; i++)
{
list.Add(rand.Next(5000));
}
int[] arr = list.ToArray();
int chk = 0;
Stopwatch watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
int len = list.Count;
for (int i = 0; i < len; i++)
{
chk += list[i];
}
}
watch.Stop();
Console.WriteLine("List/for: {0}ms ({1})", watch.ElapsedMilliseconds, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
for (int i = 0; i < arr.Length; i++)
{
chk += arr[i];
}
}
watch.Stop();
Console.WriteLine("Array/for: {0}ms ({1})", watch.ElapsedMilliseconds, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in list)
{
chk += i;
}
}
watch.Stop();
Console.WriteLine("List/foreach: {0}ms ({1})", watch.ElapsedMilliseconds, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in arr)
{
chk += i;
}
}
watch.Stop();
Console.WriteLine("Array/foreach: {0}ms ({1})", watch.ElapsedMilliseconds, chk);
Console.ReadLine();
}
}
其他回答
很容易测量…
在少量的紧循环处理代码中，我知道长度是固定的，我使用数组来进行额外的微小优化;如果你使用索引器/ for表单，数组可以稍微快一点——但是IIRC认为这取决于数组中数据的类型。但除非你需要进行微观优化，否则尽量保持简单，使用List<T>等。
当然，这只适用于读取所有数据的情况;对于基于键的查找，字典会更快。
下面是我使用“int”的结果(第二个数字是一个校验和，以验证它们都做了相同的工作):
(修改bug)
List/for: 1971ms (589725196)
Array/for: 1864ms (589725196)
List/foreach: 3054ms (589725196)
Array/foreach: 1860ms (589725196)
基于试验台:
using System;
using System.Collections.Generic;
using System.Diagnostics;
static class Program
{
static void Main()
{
List<int> list = new List<int>(6000000);
Random rand = new Random(12345);
for (int i = 0; i < 6000000; i++)
{
list.Add(rand.Next(5000));
}
int[] arr = list.ToArray();
int chk = 0;
Stopwatch watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
int len = list.Count;
for (int i = 0; i < len; i++)
{
chk += list[i];
}
}
watch.Stop();
Console.WriteLine("List/for: {0}ms ({1})", watch.ElapsedMilliseconds, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
for (int i = 0; i < arr.Length; i++)
{
chk += arr[i];
}
}
watch.Stop();
Console.WriteLine("Array/for: {0}ms ({1})", watch.ElapsedMilliseconds, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in list)
{
chk += i;
}
}
watch.Stop();
Console.WriteLine("List/foreach: {0}ms ({1})", watch.ElapsedMilliseconds, chk);
chk = 0;
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 100; rpt++)
{
foreach (int i in arr)
{
chk += i;
}
}
watch.Stop();
Console.WriteLine("Array/foreach: {0}ms ({1})", watch.ElapsedMilliseconds, chk);
Console.ReadLine();
}
}
不要试图通过增加元素数量来增加容量。
性能
List For Add: 1ms
Array For Add: 2397ms
Stopwatch watch;
#region --> List For Add <--
List<int> intList = new List<int>();
watch = Stopwatch.StartNew();
for (int rpt = 0; rpt < 60000; rpt++)
{
intList.Add(rand.Next());
}
watch.Stop();
Console.WriteLine("List For Add: {0}ms", watch.ElapsedMilliseconds);
#endregion
#region --> Array For Add <--
int[] intArray = new int[0];
watch = Stopwatch.StartNew();
int sira = 0;
for (int rpt = 0; rpt < 60000; rpt++)
{
sira += 1;
Array.Resize(ref intArray, intArray.Length + 1);
intArray[rpt] = rand.Next();
}
watch.Stop();
Console.WriteLine("Array For Add: {0}ms", watch.ElapsedMilliseconds);
#endregion
static long[] longs = new long[500000];
static long[] longs2 = {};
static List<long> listLongs = new List<long> { };
static void Main(string[] args)
{
Console.CursorVisible = false;
Stopwatch time = new Stopwatch();
time.Start();
for (int f = 50000000; f < 50255000; f++)
{
listLongs.Add(f);
}
//List Time: 1ms Count : 255000
Console.WriteLine("List Time: " + time.ElapsedMilliseconds + " | Count: " + listLongs.Count());
time.Restart();
time.Start();
for (long i = 1; i < 500000; i++)
{
longs[i] = i * 200;
}
//Array Time: 2ms Length: 500000 (Unrealistic Data)
Console.WriteLine("Array Time: " + time.ElapsedMilliseconds + " | Length: " + longs.Length);
time.Restart();
time.Start();
for (int i = 50000000; i < 50055000; i++)
{
longs2 = longs2.Append(i).ToArray();
}
//Array Time: 17950ms Length: 55000
Console.WriteLine("Array Append Time: " + time.ElapsedMilliseconds + " | Length: " + longs2.Length);
Console.ReadLine();
}
| Type | Time | Len |
|---|---|---|
| Array | 2ms | 500000 |
| List | 1ms | 255000 |
| Array Append | 17950ms | 55000 |
如果您计划不断地向数组中添加少量数据，那么list更快
这实际上取决于你将如何使用数组。
我想表演会很相似。 在使用List和Array时所涉及的开销是，恕我直言，当您向列表中添加项时，当列表必须增加它在内部使用的数组的大小时，当数组的容量达到时。
假设你有一个容量为10的List，那么一旦你想添加第11个元素，List就会增加它的容量。 可以通过将列表的Capacity初始化为它将容纳的项数来减少性能影响。
但是，为了弄清楚遍历List是否与遍历数组一样快，为什么不对其进行基准测试呢?
int numberOfElements = 6000000;
List<int> theList = new List<int> (numberOfElements);
int[] theArray = new int[numberOfElements];
for( int i = 0; i < numberOfElements; i++ )
{
theList.Add (i);
theArray[i] = i;
}
Stopwatch chrono = new Stopwatch ();
chrono.Start ();
int j;
for( int i = 0; i < numberOfElements; i++ )
{
j = theList[i];
}
chrono.Stop ();
Console.WriteLine (String.Format("iterating the List took {0} msec", chrono.ElapsedMilliseconds));
chrono.Reset();
chrono.Start();
for( int i = 0; i < numberOfElements; i++ )
{
j = theArray[i];
}
chrono.Stop ();
Console.WriteLine (String.Format("iterating the array took {0} msec", chrono.ElapsedMilliseconds));
Console.ReadLine();
在我的系统上;遍历数组需要33msec;遍历列表花费了66msec。
说实话，我没想到变化会这么大。 所以，我把我的迭代放在一个循环中:现在，我执行了1000次迭代。 结果如下:
迭代List需要67146毫秒 迭代数组需要40821毫秒
现在，变化不再那么大了，但仍然……
因此，我已经启动了。net Reflector, List类的索引器的getter看起来像这样:
public T get_Item(int index)
{
if (index >= this._size)
{
ThrowHelper.ThrowArgumentOutOfRangeException();
}
return this._items[index];
}
如您所见，当您使用List的索引器时，List会执行一次检查，检查您是否没有超出内部数组的边界。这种额外的检查是有成本的。
由于List<>在内部使用数组，因此基本性能应该是相同的。为什么这个列表可能会稍微慢一些，有两个原因:
要在列表中查找元素，调用list方法，该方法在底层数组中进行查找。所以你需要一个额外的方法调用。另一方面，编译器可能会识别出这一点，并优化“不必要的”调用。 如果编译器知道数组的大小，它可能会做一些特殊的优化，而对于一个未知长度的列表，它就不能这样做。如果列表中只有几个元素，这可能会带来一些性能改进。
要检查它是否对您有任何影响，最好将发布的计时函数调整为您计划使用的大小列表，并查看您的特殊情况的结果如何。
推荐文章
- c#中比较数组的最简单方法
- 我如何创建目录，如果它不存在，以创建文件?
- 我如何分割一个字符串由一个多字符分隔符在c# ?
- Javascript reduce()在对象
- Mockito.any()传递带有泛型的接口
- Java数组有最大大小吗?
- [].slice的解释。调用javascript?
- 按类型查找WPF窗口中的所有控件
- 数组与列表的性能
- 使用私有静态方法的优点
- Swift设置为Array
- 我如何能在Swift扩展类型化数组?
- 为什么这个迭代的列表增长代码给出IndexError:列表赋值索引超出范围?如何重复添加(追加)元素到列表?
- 从Description属性中获取Enum
- 如何在C中将数组初始化为0 ?
