What is the difference between Array and ArrayList (atleast 2)?

 Here are two key differences between an Array and an ArrayList:

Type Safety:

• Arrays are statically typed, meaning they hold elements of a specific type. Once an array is created, its type cannot be changed.
• ArrayLists, on the other hand, are dynamically typed and can hold elements of any type. They use object references to store elements, allowing for flexibility but sacrificing type safety.
• With an array, the type is known at compile-time, providing stronger type checking and preventing type-related errors.

• Arrays have a fixed size that is determined at the time of creation. The size cannot be changed once the array is created.
• ArrayLists, in contrast, are dynamically resizable. They automatically resize themselves as elements are added or removed. The size can grow or shrink dynamically as needed.
• Resizing an array requires creating a new array with a different size and copying the elements, whereas an ArrayList handles resizing internally.

Dynamic Resizing:

Example:

// Array example
int[] array = new int[3];  // Fixed-size array
array[0] = 1;
array[1] = 2;
array[2] = 3;

// ArrayList example
ArrayList arrayList = new ArrayList();  // Resizable ArrayList
arrayList.Add(1);
arrayList.Add("Two");
arrayList.Add(true);

In the above example:

• The array is of type int[] and has a fixed size of 3. It can only hold integers.
• The ArrayList is of type ArrayList and can hold elements of different types. It starts empty and grows dynamically as elements are added.

When to use an Array:

• When you know the size of the collection in advance and need a fixed-size container with a specific type.
• When you want to optimize for performance and memory usage.
• When you want strong type checking and compile-time safety.

When to use an ArrayList:

• When the collection size is not known in advance and needs to grow or shrink dynamically.
• When you need to store elements of different types within a single collection.
• When you require flexibility and are willing to trade some performance and type safety for it.

Note: In modern C#, it is recommended to use generic collections such as List<T> instead of ArrayList as they provide type safety and better performance.