Speed testing array vs. List<int>

Question

0.00/5 (No votes)

See more:

In some article i read that arrays are faster than generic list, but i got different results (or i was wrong).

What I have tried:

C#

static int[] brojevi;

        static List<int> mojaLista = new List<int>(10000);// when capacity not specified elapsed time is 00:00:00.0000199
        
        private void button_Click(object sender, RoutedEventArgs e)
        {
            ////// using array //////////
            //stopWatch.Start();
            //for (int i = 0; i < brojevi.Length - 1; i++)
            //{
            //    i = i + 1;                                  // elapsed time is 00:00:00.0000221
            //}
            //stopWatch.Stop();
            //TimeSpan ms = stopWatch.Elapsed;
            //MessageBox.Show(ms.ToString());

            ////// using list<int> ///////
            stopWatch.Start();
            for (int i = 0; i < mojaLista.Count; i++)
            {
                i = i + 1;                                      // elapsed time is 00:00:00.0000213
            }
            stopWatch.Stop();
            TimeSpan ms = stopWatch.Elapsed;
            MessageBox.Show(ms.ToString());
        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            //brojevi = new int[10000];
            //for (int i = 0; i < 10000; i++)
            //{
            //    brojevi[i] = i;
            //}

            for (int i = 0; i < 10000; i++)
            {
                mojaLista.Add(i);
            }
        }

Posted 9-Feb-20 4:44am

Gruja82

Updated 9-Feb-20 5:07am

Patrice T

v4

Add a Solution

3 solutions

Solution 2

As Dave says: an Array will always be faster than a List, simply because a List is array with a wrapper class: List<T> - Is it really as efficient as you probably think?[^]

Posted 9-Feb-20 5:05am

OriginalGriff

Solution 3

Quote:
In some article i read that arrays are faster than generic list, but i got different results (or i was wrong).

You are wrong!
The problem is that your code don't try to access list or array.
Your code is optimized by compiler:

C#

stopWatch.Start();
// because the loop to not do anything with the list, the count is handled as a constant of the loop and accessed once.
int Tmp= mojaLista.Count;
for (int i = 0; i < Tmp; i++)
{
    i = i + 1; // this is only adding 1 to the loop counter
}

and can be:

C#

stopWatch.Start();
int Tmp= mojaLista.Count;
for (int i = 0; i < Tmp; i+=2)
{
}

Nothing can beat an array on read/write.
A list is faster than array when you need to resize (add or remove elements).

Posted 9-Feb-20 5:08am

Patrice T

Updated 9-Feb-20 5:26am

v2

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Dave Kreskowiak · Accepted Answer · 2020-02-09T04:55:00

List will always be slower than an array.

Your Button_Click method where most of the code is commented out doesn't do anything at all with an array or a list, unless you're testing the Length and Count properties. That's not really a good test.

The reason List will always be slower is because of how a List works. Internally, it maintains an array. It's managed by the methods exposed by List and those methods add overhead to the execution.

For example, to put an item in an array, you simply use an index into the array and set that index to whatever you're adding. The Add method of the array maintains the next available index itself, but has to check to see if the next index is still without the bounds of the array it has allocated. If it's not, a new array has to be allocated and the objects in the old array moved over to it.