5. Collections

• Arrays • Other basic data structures• .NET collections• Class library example

Arrays

Collections are ways of storing groups of objects. Different collection types have different properties that make them suitable for different situations.

The most basic collection type is an array.

Support for arrays are built in to most languages.

Arrays are single entities with a single name that refer to multiple objects of the same type.

The elements of an array are referred to by an array index or subscript that identifies the current item in the array.

Arrays

Declaring an array - example:

int[] a;

In this case a variable called “a” is a reference or placeholder for an array of integers.

It can be pointed to an array object, initialized with the “new” operator:

a = new int[5];

Elements in the array can then be accessed using the subscript in brackets. Subscripts start at zero:

a[2] = 5;

Arrays

Arrays normally go hand-in-hand with loops:

for(int i=0; i<5; i++)

{

a[i] = i+1;

}

C# has an additional keyword just for iterating over collections, foreach:

foreach(int i in a)

{

MessageBox.Show(a[i].ToString());

}

Arrays

In C#, arrays also have a built-in length property (more on properties later):

for(int i=0; i<a.Length; i++){

a[i] = i;}

There are also built-in static methods in the System.Array class that are useful, such as Sort(), IndexOf(), Reverse(), etc.

if (Array.IndexOf(a, 4) == 4){

MessageBox.Show(“Bingo!”);}

Note that the method is part of the Array class, not a specific array.

ArraysArray members are assigned a default value. Numbers are assigned zero, and reference

types are assigned null. Arrays can be initialized in one step, for example:

int[] myIntArray = new int[5] {5,6,7,8,9}

Orint[] myIntArray = {5,6,7,8,9};

C# has a keyword params that lets you pass a variable number of parameters to a method and treat them as an array, for example:

DisplayValues(1,2,3,4,5);

public void DisplayValues(params int[] intVals)

{

foreach(int i in intVals)

{

MessageBox.Show(i.ToString());

}

}

Arrays

Each array element can also be an array, which results in a multidimensional array.

A rectangular array has sub-arrays of equal length. A jagged array has sub-arrays of variable length.

Rectangular arrays are especially useful for storing anything that has rows and columns, like the pixels in an image, or rows and columns in a spreadsheet.

Arrays

Iterating over a multi-dimensional array typically involves creating a loop for each dimension.

const int iRows = 3;

const int iCols = 3;

int[,] matrix = new int[iRows, iCols];

for (int i=0; i<iRows; i++)

{

for (int j=0; j<iCols; j++)

{

matrix[i, j] = i + j;

}

}

MessageBox.Show((matrix[0,0] * matrix[2,2]).ToString());

Arrays

A bitmap image can be thought of as a two-dimensional array of pixel values. This example transforms an image into a grayscale image containing the blue component of each pixel value:

// Bitmap is a built-in .NET object

Bitmap curBitmap = new Bitmap(mapPictureBox.Image);

int yMax = curBitmap.Size.Height;

int xMax = curBitmap.Size.Width;

for (int y = 0; y < yMax; y++)

{

for (int x = 0; x < xMax; x++)

{

Color c = curBitmap.GetPixel(x, y);

curBitmap.SetPixel(x, y, Color.FromArgb(c.B, c.B, c.B));

}

}

mapPictureBox.Image = curBitmap;

Arrays

The contents of an array can be object references.

The references must be of the same type.

// Line object is programmer-defined.

Line[] myLine = new Line[5];

for (int i = 0; i < 5; i++)

{

myLine[i] = new Line();

}

Arrays

Arrays have the advantage of performing well, and being simple to use.

However, they are hard to restructure. For example, deleting an item requires moving all the subsequent items and shortening the array. Inserting requires moving all the subsequent items and lengthening the array.

They are best used to store of things that are relatively static in their structure.

Linked List

A linked list is a classic data structure that solves some of the problems of arrays.

Each node in a list has a pointer (or reference) to the next node in the list:

Linked List

To insert an item, the adjacent items need only have their pointers updated. Deleting an item just entails changing the neighboring references:

Tree

A tree is another classic data structure often used in algorithms related to sorting or indexing data. Each node contains a reference to one parent and one or more children:

There are many varieties of trees, such as binary trees (each node has two children), quadtrees (each node has four children), and many others (more details here).

Graph

A graph is a more general case of a set of interconnected nodes (more details here). Graphs are used in network modeling and there are many related algorithms in areas such as route selection:

.NET Collections

In day-to-day programming, you normally don’t have to implement linked lists, trees, or graphs, but they are fundamental to many basic computer science algorithms.

The .NET framework includes multiple built-in data structures that will meet most routine programming requirements.

The ArrayList is a very useful built-in collection. It behaves like both an array and a list.

Items are ordered like an array, but can be inserted and deleted easily.

.NET Collections

ArrayList example:

ArrayList myList = new ArrayList();

for (int i = 0; i < 5; i++)

{

myList.Add(i * 1.5);

}

for (int i = 0; i < myList.Count; i++)

{

MessageBox.Show(i.ToString());

}

.NET Collections

Example of a class that uses an ArrayList to store geometry:

Note the typecast required to treat the ArrayList item as a geometry object.

Array list elements are treated as type Object, so need to be cast to be used as any particular type.

.NET Collections

Note that the ForEach keyword removes the need for the typecast within the loop:

.NET Collections

In version 1.x of .NET, collection classes were un-typed. That is, all of the stored objects were of type Object.

That means, each item must be cast to the applicable type before it is used.

C# 2.0 adds support for Generics, which allow you to create typed collections.

The List class is the .NET 2.x equivalent of the ArrayList (ArrayList is still available).

.NET Collections

Note the < > syntax where the list is declared. This defines the list to contain only elements of the Geometry type.

Using the generic syntax, the List is now typed correctly, and there is no need to cast it from the Object type to Geometry.

.NET Collections

Other built-in collections that are available include HashTable (.NET 1.x) and Dictionary (.NET 2.x). These are ideal for storing values that are referenced by another value. Each item has a key and value, and the key is used to locate the value:

.NET Collections

Other built-in collections that are available include Stacks and Queues. Stacks are last-in-first-out:

.NET Collections

Queues are first-in-first-out. Message queues, where each message is processed in turn, is a typical application of a queue:

Designing Classes

With collections and objects, we now have everything we need to design a simple geometry class library.

Starting with a basic point and line classes…

Designing Classes

We can now add support for objects requiring multiple points or lines, such as polygons or arbitrary collections of geometry objects.

Designing Classes

These examples are not realistic for a real class library, but enough to illustrate some object oriented programming concepts.

A more complete geometry class library can be found in, for example, an implementation of the Simple Features Spec.