Which is better to use array or List<>?

Question

I was wondering which type would have better performance and which you think should be used.

For example I have a List of strings not knowing how many items I will need so having the .Add(String) function is really convenient. I can Add new strings to the list at any time easily.

What are the advantages/disadvantages of using each?

Are lists the new arrays?

Answer 1

List<String> is implemented using an array String[].

If you don't know how many elements you'll have, use List<String>

You can give the estimated (or maximum) number of elements you expect in the capacity constructor parameter (new List<String>(10)), this will be the initial size of the underlying array.

When you Add() an item and there is no room for this item, the underlying array is copied to a new array of double the size.

What I do: when I know the exact size of the collection and I know I won't change the size of the collection, I use an array (String[]). Otherwise I use a List<String>.

By the way, this goes for any type and not just String.

Answer 2

It depends on usage scenario, BUT it's also a micro-optimisation until you have identified a bottleneck by profiling. Use whatever fits the usage best.

Answer 3

If you don't know the size of items to be added, always go for List<string> than string array.

Answer 4

If you need dynamic sizing, then go with List<string>.

If you're worried about performance, then I would suggest starting with List<string> and see if there's really an issue. It uses arrays internally so I would think, for the most part, there should be no performance issues.

If you have a staticly sized collection, you could still use string[].

Answer 5

Of course it depends on your application, but in circumstances List<string> (or even just IEnumerable<string> is preferable.

Answer 6

Use List<> in most all cases, and don't worry about performance. There is a good chance you will go through your entire career and never need to performance tune by converting a List<> into an array.

Answer 7

In most scenarios the performance difference is not appreciable so I would use List<string> since it provides much more functionality that could be useful in different situations.

Answer 8

More context is really required to answer the question properly:

In a public API, you should try to use abstract collection types, so that you can change the internal implementation later if you need to.

• If the collection should not be changed by the outside world, use IEnumerable<T>.
• If the collection will be changed by the outside world, use ICollection<T>.
• If indexed access is required, use IList<T>.

In a private implementation, it's not as important to use the abstract types:

• If you need indexed access and know the final size, use T[] or List<T>.
• If you need indexed access and don't know the final size, use List<T>.
• If you plan to access elements in a LIFO pattern, use Stack<T>.
• If you plan to access elements in a FIFO pattern, use Queue<T>.
• If you need to access elements at the beginning and end of the list, but not in the middle, use LinkedList<T>.
• If you don't want duplicates, use HashSet<T>.

In .NET 4.0 you have a few more choices, but those are the basics.