Which is better to use array or List<>? [duplicate]

Answer 1

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 2

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

Answer 3

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 4

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 5

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 6

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.