C# 哪个更有效： List<int> 或 int[]
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/1168915/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Which one is more efficient : List<int> or int[]
提问by Tarik
Can someone tell me which one is more efficient between List<int>and int[]. Because I am working on a project and as you might know efficiency is way so important concern now.
有人能告诉我List<int>和之间哪个更有效吗int[]？因为我正在做一个项目，你可能知道效率现在是非常重要的问题。
If you added some introductory note to your post, it'd be great tho :)
如果您在帖子中添加了一些介绍性说明，那就太好了 :)
采纳答案by Sam Harwell
(list should be resizable) ? List<int> : int[]
List<int>is a wrapper for int[]that resizes as needed. With JIT inlining, they should perform almostidentically, but the JIT will have an easier time edging out the extra performance from int[]because it's a CLI primitive with dedicated IL instructions.
List<int>是int[]根据需要调整大小的包装器。使用 JIT 内联，它们的性能应该几乎相同，但 JIT 将更容易消除额外的性能，int[]因为它是具有专用 IL 指令的 CLI 原语。
回答by Shawn
List uses an array internally, so using an array (correctly) would always be more (or atleast as) efficient.
List 在内部使用数组，因此（正确）使用数组总是会更（或至少）更有效。
回答by Dan Tao
If you know exactly how many elements are going to be in the collection and don't need any of the extra features of List<int>AND (that is a very serious AND) performance is a serious concern, go with int[]. Otherwise stick with List<int>.
如果您确切知道集合中有多少元素并且不需要List<int>AND（这是一个非常严重的AND）的任何额外功能，那么性能是一个严重的问题，请使用int[]. 否则坚持List<int>。
回答by user106596
If you plan on using any features that a list would provide (searching, sorting, removing, resizing) then I would go with a list because chances are these functions are very optimized already and you won't be able to write better versions of them.
如果您打算使用列表提供的任何功能（搜索、排序、删除、调整大小），那么我会使用列表，因为这些功能可能已经非常优化，您将无法编写更好的版本.
回答by Cyberherbalist
Just for the fun of it, I ran this:
只是为了好玩，我运行了这个：
int cap = 100000;
Stopwatch sw1 = new Stopwatch();
sw1.Start();
int[] ix = new int[cap];
for (int x = 0; x < cap; x++)
{
ix[x] = 1;
}
sw1.Stop();
Stopwatch sw2 = new Stopwatch();
sw2.Start();
List<int> iy = new List<int>(cap);
for (int y = 0; y < cap; y++)
{
iy.Add(y);
}
sw2.Stop();
Console.WriteLine(cap.ToString() + " int[]=" + sw1.ElapsedTicks.ToString());
Console.WriteLine(cap.ToString() + " List<int>=" + sw2.ElapsedTicks.ToString());
Console.ReadKey();
And got this:
得到了这个：
100000 int[]=1796542 100000 List=2517922
I tried it in elapsed milliseconds and got 0 and 1 respectively. Clearly the int[] is way faster, but unless you're talking huge arrays, I'd say it is just nominal.
我在经过的毫秒内尝试过，分别得到 0 和 1。显然 int[] 更快，但除非你说的是巨大的数组，否则我会说它只是名义上的。
回答by Edwin Tai
the latter is more effective.
In the source code, List<>is named by some Arrays.
Eg, List<Type> aa=new List<Type>();
In general, an array Type[]is declared, the length of it is a certain number.
In another word, if you declare a List<>, a big space has already used.
If the List<>'selement is out of length, the array should be copied to another bigger one.
So, it is better not to use List<>.
The better way to use is to declared the length of it.
List aa=new List<Type>(10);
后者更有效。
在源代码中，List<>由一些数组命名。
例如，List<Type> aa=new List<Type>();
一般情况下，array Type[]声明了一个an ，它的长度是一个特定的数字。换句话说，如果声明 a List<>，则已经使用了很大的空间。
如果List<>'s元素超出长度，则应将数组复制到另一个更大的数组。所以，最好不要使用List<>。
更好的使用方法是声明它的长度。
列表aa=new List<Type>(10);
