ArrayList Class

The ArrayList class is a weakly-typed collection class. It is found in the System.Collections namespace.

As it is weakly typed, it can contain a heterogeneous collection of elements, that is, of various types.

As a list, it has both a Count (number of elements present) and a Capacity (number of elements the list can contain without resizing). When Count reaches Capacity, Capacity is automatically enlarged.

Constructors: (some of them)

• ArrayList()

  This creates a new empty ArrayList with the default Capacity.

• ArrayList(int C)

  This creates a new empty ArrayList with initial Capacity = C.

Properties: (some of them)

• int Capacity:

  Get or set the number of elements the ArrayList can contain without resizing.

• int Count:

  Get the number of elements actually in the ArrayList at present.

Indexer:

• Object this[int N]

  Get or set the element at the specified index. Here 0 <= N < Count.

Methods: (a few of them)

• void Add(Object OBJ)

  Add the element OBJ at the end of the collection.

• void Clear()

  Remove all elements from the ArrayList; Capacity is unchanged.

• bool Contains(Object Target)

  This returns true if Target is in the ArrayList and false otherwise.

• void CopyTo(Array A)

  This copies the entire ArrayList to the one-dimensional array A, which must be compatible.

• int IndexOf(Object Target)

  This returns the index of the first occurrence of Target in the ArrayList, or -1 if not found.

• void RemoveAt(int N)

  Remove the element at index N. Count is decremented.

• void Reverse()

  Reverse the order of elements in the ArrayList.

• void TrimToSize()

  Reduce Capacity to the value of Count.

Notes:

There are also methods to sort the ArrayList or to perform a binary search. Sorting requires that the elements should satisfy the IComparer interface (so we need a comparison method).

An ArrayList can contain null values and can have duplicate elements.

For homogeneous elements (all the same type T), an alternative is the List<T> class.

For heterogeneous elements, an alternative is the List<Object> class.