C# ArrayList

ArrayList

ArrayList dynamically resizes.
As elements are added,
and space is needed,
it grows in capacity. It is most often used in older C# programs. It stores elements of type object—casting is needed.

Object

Add

The Add method on ArrayList is often used. It appends a new element object to the end of the ArrayList. We can keep adding elements to the collection until memory runs out. The objects are stored in the managed heap.

Summary

Here:We see a complete console program. When you run it, three elements are added to the ArrayList.

Elements:The first element is a string containing "One." The last element is "Three."

String Literal
Based on:

.NET 4.5

Program that uses ArrayList: C#

using System.Collections;

class Program
{
    static void Main()
    {
	//
	// Create an ArrayList and add three elements.
	//
	ArrayList list = new ArrayList();
	list.Add("One");
	list.Add("Two");
	list.Add("Three");
    }
}

Arguments

Method call

Structural programming with ArrayList is easy, as you can simply pass the object with the ArrayList type. However, in the receiving function, you have to know (or find out) the type of each element.

Next:In this program we pass the ArrayList as an argument to the Example() method.

Program that uses ArrayList parameter: C#

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);
	}
    }
}

Output

5
7
Return keyword

ArrayList as return value. You can also use the ArrayList as a return value. Use the ArrayList type as the return keyword at the start of your method. It is usually best to reuse the same ArrayList instead of combining more than one.

Combine

Plus

There are different ways to combine one ArrayList with another. But the best way is using AddRange. Internally, AddRange uses the Array.Copy or CopyTo methods, which have better performance than some loops.

Here:The first ArrayList has two elements added to it. Next, the second ArrayList has two elements added.

Then:The second ArrayList is appended to the first using the AddRange method. The example finally shows the output.

Array.CopyConsole.WriteLine
Program that uses Add and AddRange: C#

using System;
using System.Collections;

class Program
{
    static void Main()
    {
	//
	// 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);
	}
    }
}

Output

5
7
10
13

Count

Property

ArrayList provides the Count property, which is a virtual property. When you use Count, no counting is actually done. Instead a cached field value is returned. This means that Count is fairly fast.

Here:The example shows the Count property. It also shows the Clear method, and how this affects the count.

Program that uses Count: C#

using System;
using System.Collections;

class Program
{
    static void Main()
    {
	//
	// 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);
    }
}

Output

2
0
Int keyword

The Count property returns an int. This will always be a positive value. Sometimes, you can store the count in a local variable for better performance. But this isn't usually needed. No calculation takes place in the property itself.

Int

Clear:You can call the instance method Clear on your ArrayList. Internally, this calls the Array.Clear method.

Array.Clear

Sometimes:Code is clearer if you instead create a new ArrayList. This may also affect performance.

Sort, reverse

Sorted letters: A to Z

Many dynamic arrays such as ArrayList must be sorted frequently, before insertion into the output web page or Windows program. We call the instance Sort method and then Reverse. These methods work in-place.

Tip:You can sort subsets (ranges) of elements in your ArrayList using the third overload. This is useful in rare situations.

Also:You can Reverse only a range of your ArrayList. This is useful even less often.

Program icon

Sorting an ArrayList is often done. It provides a view of the data that is helpful for both users and computers. The Sort method in the base class libraries is an instance method (with no parameters) on ArrayList.

Elements:The ArrayList Sort method works on different element types. The example here shows strings.

Program that sorts ArrayList and reverses: C#

using System;
using System.Collections;

class Program
{
    static void Main()
    {
	//
	// 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);
	}
    }
}

Output

Cat
Cow
Dog
Zebra

Zebra
Dog
Cow
Cat
Net

The above console program defines the Main entry point. In Main an ArrayList is declared and populated with several strings. The Sort method is then called. Its results are displayed next.

Finally:The collection is reversed. You can see the foreach-loops on ArrayList here as well.

Internally, the Sort method ends up in an internal TrySZSort or QuickSort method when it doesn't throw an exception. TrySZSort is optimized for one-dimensional arrays, also known as "Zero" arrays or vectors.

Performance

Performance of Sort. Because the TrySZSort method used in the base class libraries is implemented in native code, it has been heavily optimized. This method is likely faster than any solution written in the C# language.

Thus:Using Sort on ArrayList or on Array is faster than most custom implementations.

Insert, remove

Insert: placing an element into a collection

Next, we insert and remove elements in the ArrayList. We use the Insert and Remove family of methods. We see the RemoveAt method for erasing a single element, and then Insert and RemoveRange.

Tip:The first argument to Insert is the position: this is equivalent to the index of the element.

Program that uses Insert and Remove: C#

using System;
using System.Collections;

class Program
{
    static void Main()
    {
	//
	// 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"
	}
    }
}

Output

Perls

Loop

For loop

The for-loop is popular and useful. When using for on an ArrayList, you will need to cast the element after using its index. The [i] part in the example below demonstrates how to use the indexer on the ArrayList.

Indexer
Program that uses ArrayList and for: C#

using System;
using System.Collections;

class Program
{
    static void Main()
    {
	//
	// 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);
	}
    }
}

Output

man
woman
plant
As keyword

Cast:The "as" cast in C# is probably the best way to cast reference types such as string.

As

Tip:After you cast, you can check the result for null before using the variable, to see if the cast succeeded.

GetRange

Method

Another method you can use is the GetRange method. 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.

SetRange:The SetRange method on ArrayList is also useful when you need to replace a range.

However:I have not found SetRange to be useful, as often you will just want to replace elements in a for-loop.

Program that uses GetRange: C#

using System;
using System.Collections;

class Program
{
    static void Main()
    {
	//
	// 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
	}
    }
}

Output

bird
plant

IndexOf

Programming tip

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. IndexOf will return -1 if the element could not be located.

IndexOf

Convert

Convert or change

Arrays offer more performance and compatibility, so you will want to convert ArrayLists to arrays. Due to the boxing and unboxing requirements with the ArrayList, you need to specify more complex casts than with the List constructed type.

Convert ArrayList, Array

Discussion

Question

It is usually better to use List. But older applications may be using ArrayList. And it is often best not to have to rewrite them. Lists not only avoid boxing or unboxing, but they also lead to clearer and less bug-prone code.

Note:With List, the compiler can check your code for type integrity before runtime. This improves reliability.

List

Performance:There is a performance penalty in using ArrayList, particularly on value types. This is because boxing (and unboxing) occurs.

UnboxingABC: letters

The BinarySearch method on ArrayList implements the binary searching algorithm. This uses a "divide and conquer" approach to finding the correct element. It only works on a presorted array.

Thus:Never use BinarySearch if your ArrayList might not be already sorted. The results could be invalid.

BinarySearch List

Summary

ArrayList is a collection that is best avoided. But it is often used in older legacy programs—so it must be supported. Newer .NET Framework versions offer better collections in System.Collections.Generic.


C#: Collections