Array vs ArrayList in C#: Understanding the Differences

Category > CSHARP || Published on : Friday, March 17, 2023 || Views: 24 || C# programming data structures arrays ArrayLists.


In C#, both arrays and ArrayLists are used to store collections of data. While they may seem similar at first glance, there are important differences between the two that can affect performance and usability. In this article, we'll explore the differences between arrays and ArrayLists in C#, and provide examples of when to use each data structure.

In C#, both arrays and ArrayLists are used to store collections of data. However, there are some key differences between the two that are important to understand.

Arrays are fixed-size collections of elements of the same type. They are declared using the square bracket notation, like this:

int[] myArray = new int[10];

In this example, we declare an array of integers with a length of 10. Once the array is created, its length cannot be changed. You can access elements of an array using their index, like this:

int myValue = myArray[0];

Arrays are generally faster than ArrayLists because they are stored in contiguous memory and have a fixed size. However, they can be more difficult to work with because their size cannot be changed.

ArrayLists, on the other hand, are dynamic collections of objects. They can grow or shrink in size as needed, and can contain elements of different types. They are declared like this:

ArrayList myList = new ArrayList();

To add an element to an ArrayList, you use the Add method, like this:

myList.Add("Hello");

To access an element of an ArrayList, you use its index, like this:

string myValue = (string)myList[0];

Note that because ArrayLists can contain elements of different types, you need to cast the value when you access it.

ArrayLists are more flexible than arrays because their size can change, but they can be slower because they are not stored in contiguous memory.

In summary, arrays are fixed-size collections of elements of the same type, while ArrayLists are dynamic collections of objects that can grow or shrink in size. Arrays are generally faster, but can be more difficult to work with, while ArrayLists are more flexible, but can be slower.

It's important to choose the right data structure for your needs. If you need a fixed-size collection of elements of the same type, an array is a good choice. If you need a dynamic collection of objects of different types, an ArrayList might be a better option.

Here's an example code that demonstrates the difference between arrays and ArrayLists:

// Declare an array of integers
int[] myArray = new int[3];
myArray[0] = 1;
myArray[1] = 2;
myArray[2] = 3;

// Declare an ArrayList of integers
ArrayList myList = new ArrayList();
myList.Add(1);
myList.Add(2);
myList.Add(3);

// Output the values
Console.WriteLine("Array values:");
foreach (int value in myArray)
{
    Console.WriteLine(value);
}

Console.WriteLine("ArrayList values:");
foreach (int value in myList)
{
    Console.WriteLine(value);
}

In this example, we declare an array of integers with a length of 3, and an ArrayList of integers with the same values. We then output the values of each collection using a foreach loop. The output should be:

Array values:
1
2
3
ArrayList values:
1
2
3

As you can see, both collections contain the same values, but the array is faster and has a fixed size, while the ArrayList is more flexible but slower.