Which one is more effecient : List<int> or int[]

Question

Hi,

Can some one tell me which one is more efficient between List and int[]. Because I am working on a project and as you might know efficiency is way so important concern now.

Thanks in advance.

If you added some introductory note to your post, it'd be great tho :)

Answer 1

List uses an array internally, so using an array (correctly) would always be more (or atleast as) efficient.

Answer 2

(list should be resizable) ? List<int> : int[]

List<int> is a wrapper for int[] that resizes as needed. With JIT inlining, they should perform almost identically, 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.

Answer 3

I find myself repeating this all the time:

1. I suspect that whatever you are doing, this choice is not your biggest performance hit.
2. You don't say what you mean by "efficient"; something can be efficient in time or efficient in space. You have to pick which you want to optimize for.
3. It doesn't matter what you pick: you can test either one yourself by creating an instance of both, filling it up with data, doing whatever it is your program might do, and timing it. I'll bet your salary C# has a timer class.

Answer 4

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>.

Answer 5

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.

Answer 6

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.

Answer 7

the latter is more effective.
In the source code,List<> is named by some Arrays.
Eg, List aa=new List();
In general, a 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<>'s element is out of length, the array should be copyed 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(10);