ArrayList

Sometimes we do not know how many elements to place in a collection. Usually the C# List generic type is ideal for this. But older programs can use ArrayList.

Like the List, the ArrayList dynamically resizes. It grows in capacity as elements are added (if space is needed). No special resizing code is needed.

Add method

This appends a new element object to the end. We can keep adding elements to the collection until memory runs out. The objects are stored in the managed heap.

using System;
using System.Collections;

// Create an ArrayList and add 3 elements.
ArrayList list = new ArrayList();
list.Add("One");
list.Add("Two");
list.Add("Three");
Console.WriteLine("DONE");
DONE

Arguments

It is easy to pass ArrayList as an argument. However, in the receiving function, you have to know (or find out) the type of each element.

using System;
using System.Collections;

class Program
{
    static void Main()
    {
        // Create an ArrayList and add two ints.
        ArrayList list = new ArrayList();
        list.Add(5);
        list.Add(7);

        // Use ArrayList with method.
        Example(list);
    }

    static void Example(ArrayList list)
    {
        foreach (int i in list)
        {
            Console.WriteLine(i);
        }
    }
}
5
7

Combine

We can use AddRange to combine two ArrayLists. Internally, AddRange uses the Array.Copy or CopyTo methods, which have better performance than some loops.

using System;
using System.Collections;

// Create an ArrayList with two values.
ArrayList list = new ArrayList();
list.Add(5);
list.Add(7);

// Second ArrayList.
ArrayList list2 = new ArrayList();
list2.Add(10);
list2.Add(13);

// Add second ArrayList to first.
list.AddRange(list2);

// Display the values.
foreach (int i in list)
{
    Console.WriteLine(i);
}
5
7
10
13

Count

This is a virtual property. When you use Count, no counting is done—instead a cached field value is returned. This means that Count is fairly fast.

using System;
using System.Collections;

// Create an ArrayList with two values.
ArrayList list = new ArrayList();
list.Add(9);
list.Add(10);

// Show number of elements in ArrayList.
Console.WriteLine(list.Count);

// Clear the ArrayList.
list.Clear();

// Show count again.
Console.WriteLine(list.Count);
2
0

Sort, reverse

Many dynamic arrays (such as ArrayList) must be frequently sorted. We call the instance Sort method and then Reverse. These methods work in-place.

using System;
using System.Collections;

// Create an ArrayList with four strings.
ArrayList list = new ArrayList();
list.Add("Cat");
list.Add("Zebra");
list.Add("Dog");
list.Add("Cow");

// Sort the ArrayList.
list.Sort();

// Display the ArrayList elements.
foreach (string value in list)
{
    Console.WriteLine(value);
}

// Reverse the ArrayList.
list.Reverse();

// Display the ArrayList elements again.
foreach (string value in list)
{
    Console.WriteLine(value);
}
Cat
Cow
Dog
Zebra

Zebra
Dog
Cow
Cat

Insert, Remove

Here we insert and remove elements in an ArrayList. We see the RemoveAt method for erasing a single element, and then Insert and RemoveRange.

using System;
using System.Collections;

// Create an ArrayList with three strings.
ArrayList list = new ArrayList();
list.Add("Dot");
list.Add("Net");
list.Add("Perls");

// Remove middle element in ArrayList.
list.RemoveAt(1); // It becomes [Dot, Perls]

// Insert word at the beginning of ArrayList.
list.Insert(0, "Carrot"); // It becomes [Carrot, Dot, Perls]

// Remove first two words from ArrayList.
list.RemoveRange(0, 2);

// Display the result ArrayList.
foreach (string value in list)
{
    Console.WriteLine(value); // <-- "Perls"
}
Perls

Loop

The for-loop is popular and useful. We need to cast elements after accessing them. The "i" part in the example shows how to use the indexer on the ArrayList.

using System;
using System.Collections;

// Create an ArrayList with three strings.
ArrayList list = new ArrayList();
list.Add("man");
list.Add("woman");
list.Add("plant");

// Loop over ArrayList.
for (int i = 0; i < list.Count; i++)
{
    string value = list[i] as string;
    Console.WriteLine(value);
}
man
woman
plant

GetRange

This will return a subset of the original ArrayList in a new ArrayList. This is ideal when you know a certain part of your ArrayList has a different purpose or behavior.

using System;
using System.Collections;

// Create an ArrayList with 4 strings.
ArrayList list = new ArrayList();
list.Add("fish");
list.Add("amphibian");
list.Add("bird");
list.Add("plant");

//Get last two elements in ArrayList.
ArrayList range = list.GetRange(2, 2);

// Display the elements.
foreach (string value in range)
{
    Console.WriteLine(value); // bird, plant
}
bird
plant

IndexOf

The IndexOf and LastIndexOf methods on ArrayList are similar to those on strings. You pass in the value you are looking for, the start index, the number of elements to search.

using System;
using System.Collections;

ArrayList list = new ArrayList();
list.Add(5);
list.Add(7);

// Call IndexOf.
int result = list.IndexOf(7);
Console.WriteLine("RESULT: {0}", result);
Console.WriteLine("NOT FOUND: {0}", list.IndexOf(900));
RESULT: 1
NOT FOUND: -1

Benchmark, List, ArrayList

Here we compare the performance of List (a generic collection) to ArrayList. We add, remove, test and clear each collection.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

List<int> list = new List<int>();
ArrayList array = new ArrayList();

const int max = 1000000;
var s1 = Stopwatch.StartNew();
// Version 1: use List.
for (int i = 0; i < max; i++)
{
    list.Add(10);
    list.Add(20);
    list.Add(30);
    list.Remove(30);
    if (list[list.Count - 1] != 20)
    {
        return;
    }
    list.Clear();
}
s1.Stop();
var s2 = Stopwatch.StartNew();
// Version 2: use ArrayList.
for (int i = 0; i < max; i++)
{
    array.Add(10);
    array.Add(20);
    array.Add(30);
    array.Remove(30);
    if ((int)array[array.Count - 1] != 20)
    {
        return;
    }
    array.Clear();
}
s2.Stop();
Console.WriteLine(s1.Elapsed.TotalMilliseconds);
Console.WriteLine(s2.Elapsed.TotalMilliseconds);
 67.4821 ms,    List      add, remove, test, clear
151.8429 ms,    ArrayList add, remove, test, clear

ArrayList holds objects: it stores elements of type object—casting is needed. We use as-casts, numeric casts to test elements. ArrayList is a collection that is best avoided.