Declare a Visual Basic 2005 array with the following syntax:

Dim array-name() as type

For example:

Dim intArray() as Integer

The parentheses tell the Visual Basic 2005 compiler that you are declaring an array, and the type specifies the type of the elements it will contain. In the previous example, intArray is an array of integers.

You instantiate an array using the new keyword. For example:

intArray = new Integer(5) {  }

The effect of this declaration is to create and intialize an array of six integers, all of which are initialized to the value zero.

It is important to distinguish between the array itself (which is a collection) and the elements of the array. intArray is the array (or, more accurately, the variable that holds the reference to the array); its elements are the six integers it holds.

Visual Basic 2005 arrays are reference types, created on the heap. Thus, the array to which intArray refers is allocated on the heap. The elements of an array are allocated based on their own type. Since Integers are value types, the elements in intArray will be value types, not boxed integers, and, thus, all the elements will be created inside the block of memory allocated for the array.

The block of memory allocated to an array of reference types will contain references to the actual elements, which are themselves created on the heap in memory separate from that allocated for the array.

When you create an array of value types, each element initially contains the default value for the type stored in the array. The statement:

intArray = new Integer(5) {  }

creates an array of six integers, each of whose value is set to 0, which is the default value for integer types.

On the other hand reference types in an array are not initialized to their default value. Instead, the references held in the array are initialized to null. If you attempt to access an element in an array of reference types before you have specifically initialized the elements, you will generate an exception.

Assume you have created a Button class. Declare an array of Button objects with the following statement:

Dim myButtonArray() as Button

and instantiate the actual array like this:

myButtonArray = new Button(3)

You can shorten this to:

Dim myButtonArray() as Button = new Button(3)

This statement does not create an array with references to four Button objects. Instead, this creates the array myButtonArray with four null references. To use this array, you must first construct and assign the four Button objects, one for each reference in the array.

Access the elements of an array using the index operator (()). Arrays are zero-based, which means that the index of the first element is always zero—in this case, myArray(0).

As explained previously, arrays are objects and, thus, have properties. One of the more useful of these is Length, which tells you how many objects are in an array. Array objects can be indexed from 0 to Length-1. That is, if there are five elements in an array; their indices are 0, 1, 2, 3, and 4.

Example 17-1 is a console application named Arrays, that illustrates the array concepts covered so far.

Module Module1

    Public Class Employee
        Private _empID As String
        Public Sub New(ByVal empID As Integer)
            Me._empID = empID
        End Sub
        Public Overrides Function ToString() As String
            Return _empID
        End Function
    End Class

    Sub Main()
        Dim empArray() As Employee
        empArray = New Employee(3) {  }
        Dim intArray() As Integer = New Integer(5) {  }

        For index As Integer = 0 To empArray.Length − 1
            empArray(index) = New Employee(index + 5)
        Next

        For index As Integer = 0 To intArray.Length − 1
            Console.WriteLine(intArray(index).ToString())
        Next

        For index As Integer = 0 To empArray.Length − 1
            Console.WriteLine(empArray(index).ToString())
        Next
    End Sub

End Module

Output:
0
0
0
0
0
0
5
6
7
8

The example starts with the definition of an Employee class, which implements a constructor taking a single integer parameter. The ToString() method inherited from Object is overridden to print the value of the Employee object’s employee ID.

The test method declares and then instantiates a pair of arrays. The integer array is automatically filled with integers whose value is set to 0. The Employee array contents must be constructed by hand.

Finally, the contents of the arrays are printed to ensure that they are filled as intended. The six integers print their value (zero) first, followed by the four Employee objects.

It is possible to initialize the contents of an array at the time it is instantiated by providing a list of values delimited by curly braces ({ }). Visual Basic 2005 provides a longer and a shorter syntax:

Dim firstArray()  As Integer = New Integer(5) {1, 2, 3, 4, 5, 6}
Dim secondArray() As Integer = {1, 2, 3, 4, 5, 6}

There is no practical difference between these two statements, and most programmers will use the shorter syntax.

Arrays can be thought of as long rows of slots into which values can be placed. Once you have a picture of a row of slots, imagine 10 rows, one on top of another. This is the classic two-dimensional array of rows and columns (often referred to as a Matrix).^[*]

A third dimension is possible, but somewhat harder to imagine. Okay, now imagine four dimensions. Now imagine 10.

Those of you who are not string-theory physicists have probably given up, as have I. Multidimensional arrays are useful, however, even if you can’t quite picture what they would look like.

Visual Basic 2005 supports two types of multidimensional arrays: rectangular and jagged. In a rectangular array, every row is the same length. A jagged array, however, is an array of arrays, each of which can be a different length.

Dim identifier(,) As type

Dim theMatrix(,) As Integer = New Integer(3,2) { }

Module Module1

    Sub Main()
        Const rows As Integer = 3
        Const columns As Integer = 2

        Dim theMatrix(,) As Integer = New Integer(rows, columns) {  }
        For index As Integer = 0 To rows
            For internalIndex As Integer = 0 To columns
                theMatrix(index, internalIndex) = _
                     (index + 1) * (internalIndex + 1)
            Next
        Next

        For index As Integer = 0 To rows
            For internalIndex As Integer = 0 To columns
                Console.WriteLine("theMatrix({0})({1}) = {2}", _
                index, internalIndex, theMatrix(index, internalIndex))
            Next
        Next


    End Sub

End Module

Output:
theMatrix(0)(0) = 1
theMatrix(0)(1) = 2
theMatrix(0)(2) = 3
theMatrix(1)(0) = 2
theMatrix(1)(1) = 4
theMatrix(1)(2) = 6
theMatrix(2)(0) = 3
theMatrix(2)(1) = 6
theMatrix(2)(2) = 9
theMatrix(3)(0) = 4
theMatrix(3)(1) = 8
theMatrix(3)(2) = 12

Const rows As Integer = 3
Const columns As Integer = 2

Dim theMatrix(,) As Integer = New Integer(rows, columns) {  }

Dim theMatrixReloaded(,) As Integer = New Integer(rows, columns) _
{ _
    {0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11} _
}

A jaggedarray is an array of arrays. It is called “jagged " because the rows need not be the same size, and thus a graphical representation of the array would not be square.

When you create a jagged array, you declare the number of rows in your array. Each row will hold an array, which can be of any length. These arrays must each be declared. You can then fill in the values for the elements in these “inner” arrays.

In a jagged array, each dimension is a one-dimensional array. To declare a jagged array, use the following syntax, where the number of parentheses indicates the number of dimensions of the array:

Dim identifier()() as type

For example, you would declare a two-dimensional jagged array of integers named myJaggedArray as follows:

Dim myJaggedArray()() as Integer = new Integer(5)

Access the fifth element of the third array by writing myJaggedArray(2)(4).

Example 17-3 creates a jagged array named myJaggedArray, initializes its elements, and then prints their content. To save space, the program takes advantage of the integer array elements automatically initializing to zero, and it initializes the values of only some of the elements.

Module Module1

    Sub Main()
        Const rows As Integer = 3

        ''declare the jagged array as 4 rows high
        Dim jaggedArray As Integer()() = New Integer(rows)() {  }

        '' the first row has 3 elements
        jaggedArray(0) = New Integer(2) {  }

        '' the second row has 2 elements
        jaggedArray(1) = New Integer(1) {  }

        '' the third row has 4 elements
        jaggedArray(2) = New Integer(3) {  }

        '' the fourth row has 5 elements
        jaggedArray(3) = New Integer(4) {  }

        '' fill some (not all) elements of the rows
        jaggedArray(0)(2) = 15
        jaggedArray(1)(1) = 12
        jaggedArray(2)(1) = 9
        jaggedArray(2)(2) = 99
        jaggedArray(3)(0) = 10
        jaggedArray(3)(1) = 11
        jaggedArray(3)(2) = 12
        jaggedArray(3)(3) = 13
        jaggedArray(3)(4) = 14

        For index As Integer = 0 To jaggedArray(0).Length − 1
            Console.WriteLine("jaggedArray(0)(" & index & "): {0}", _
                jaggedArray(0)(index))
        Next

        For index As Integer = 0 To jaggedArray(1).Length − 1
            Console.WriteLine("jaggedArray(1)(" & index & "): {0}", _
                jaggedArray(1)(index))
        Next

        For index As Integer = 0 To jaggedArray(2).Length − 1
            Console.WriteLine("jaggedArray(2)(" & index & "): {0}", _
                jaggedArray(2)(index))
        Next

        For index As Integer = 0 To jaggedArray(3).Length − 1
            Console.WriteLine("jaggedArray(3)(" & index & "): {0}", _
                jaggedArray(3)(index))
        Next

    End Sub

End Module

Output:
jaggedArray(0)(0): 0
jaggedArray(0)(1): 0
jaggedArray(0)(2): 15
jaggedArray(1)(0): 0
jaggedArray(1)(1): 12
jaggedArray(2)(0): 0
jaggedArray(2)(1): 9
jaggedArray(2)(2): 99
jaggedArray(2)(3): 0
jaggedArray(3)(0): 10
jaggedArray(3)(1): 11
jaggedArray(3)(2): 12
jaggedArray(3)(3): 13
jaggedArray(3)(4): 14

In this example, a jagged array is created with four rows:

Dim jaggedArray As Integer()() = New Integer(rows)() {  }

Notice that the second dimension is not specified. Each row holds an array and each of these arrays can have a different size. Indeed, you see that the first has three rows, the second has two, and so forth.

Once an array is specified for each row, you need only populate the various members of each array and then print their contents to ensure that all went as expected.

theMatrixtheMatrix(index, innerIndex)

jaggedArray(3)(index)

The classic problem with the Array type is its fixed size. If you do not know in advance how many objects an array will hold, you run the risk of declaring either too small an array (and running out of room) or too large an array (and wasting memory).

Suppose you create a program that gathers input from a web site. As you find objects (strings, books, values, etc.), you will add them to the array, but you have no idea how many objects you’ll collect in any given session. The classic fixed-size array is not a good choice, as you can’t predict how large an array you’ll need.

The List class is like an array whose size is dynamically increased as required. Lists provide a number of useful methods and properties. Some of the most important are shown in Table 17-2.

When you create a List, you do not define how many objects it will contain. Add to the List using the Add method, and the List takes care of its own internal bookkeeping, as illustrated in Example 17-4.

Imports System.Collections.Generic
Module Module1

   Sub Main()
      Dim empList As New List(Of Employee)
      Dim intList As New List(Of Integer)

      For counter As Integer = 0 To 4
         empList.Add(New Employee(counter + 100))
         intList.Add(counter + 5)
      Next


      For Each val As Integer In intList
         Console.Write(val.ToString() + " ")
      Next
      Console.WriteLine(Environment.NewLine)

      For Each emp As Employee In empList
         Console.Write(emp.ToString() + " ")
      Next
      Console.WriteLine(Environment.NewLine)
      Console.WriteLine("empList.Capacity: {0}", empList.Capacity)

   End Sub

End Module

Public Class Employee

   Private employeeID As Integer

   Public Sub New(ByVal theID As Integer)
      Me.employeeID = theID
   End Sub
   Public Overrides Function ToString() As String
      Return employeeID.ToString()
   End Function
   Public Property EmpID() As Integer
      Get
         Return employeeID
      End Get
      Set(ByVal value As Integer)
         employeeID = value
      End Set
   End Property

End Class

Output:
0 5 10 15 20
100 101 102 103 104
empArray.Capacity: 8

With an Array class, you define how many objects the array will hold. If you try to add more than that, the Array class will throw an exception. With a List, you do not declare how many objects the List will hold. The List has a property, Capacity, which is the number of elements the List is capable of storing:

public int Capacity { get; set; }

The default capacity is eight. When you add the ninth element, the capacity is automatically doubled to 16. If you change the For loop to:

For counter As Integer = 0 To 8

the output looks like this:

5 6 7 8 9 10 11 12 13
100 101 102 103 104 105 106 107 108
empList.Capacity: 16

You can manually set the capacity to any number equal to or greater than the count. If you set it to a number less than the count, the program will throw an exception of type ArgumentOutOfRangeException.

Like all collections, the List implements the Sort method, which allows you to sort any objects that implement IComparable. In the next example, you’ll modify the Employee object to implement IComparable:

Public Class Employee
   Implements IComparable(Of Employee)

To implement the IComparable interface, the Employee object must provide a CompareTo method:

Function CompareTo(ByVal rhs As Employee) As Integer _
Implements IComparable(Of IComparable.Employee).CompareTo
   Return Me.employeeID.CompareTo(rhs.employeeID)
End Function

The CompareTo method has been implemented to take an Employee as a parameter. The current Employee object must compare itself to the parameter and return -1 if it is smaller than the parameter, 1 if it is greater than the parameter, and 0 if it is equal to the parameter.

You are ready to sort the list of employees, empList. To see if the sort is working, you’ll need to add integers and Employee instances to their respective lists with (pseudo)random values. To create the random values, you’ll instantiate an object of class Random and call the Next method on the Random to return a pseudo-random number.

The Next method is overloaded; one version allows you to pass in an integer that represents the largest random number you want. In this case, you’ll pass in the value 10 to generate a random number between 0 and 10:

Random r = new Random();
r.Next(10);

Example 17-5 creates and then sorts the two lists.

Imports System.Collections.Generic
Module Module1

   Sub Main()
      Dim empList As New List(Of Employee)
      Dim intList As New List(Of Integer)

      Dim r As New Random()

      For counter As Integer = 0 To 8
         empList.Add(New Employee(r.Next(10) + 100))
         intList.Add(r.Next(10))
      Next


      For Each val As Integer In intList
         Console.Write(val.ToString() + " ")
      Next
      Console.WriteLine(Environment.NewLine)

      For Each emp As Employee In empList
         Console.Write(emp.ToString() + " ")
      Next
      Console.WriteLine(Environment.NewLine)

      intList.Sort()
      empList.Sort()
      Console.WriteLine("Sorted: ")
      For Each val As Integer In intList
         Console.Write(val.ToString() + " ")
      Next
      Console.WriteLine(Environment.NewLine)

      For Each emp As Employee In empList
         Console.Write(emp.ToString() + " ")
      Next

   End Sub

End Module
Public Class Employee
   Implements IComparable(Of Employee)

   Private employeeID As Integer

   Public Sub New(ByVal theID As Integer)
      Me.employeeID = theID
   End Sub
   Public Overrides Function ToString() As String
      Return employeeID.ToString()
   End Function
   Public Property EmpID() As Integer
      Get
         Return employeeID
      End Get
      Set(ByVal value As Integer)
         employeeID = value
      End Set
   End Property

   Function CompareTo(ByVal rhs As Employee) As Integer _
       Implements IComparable(Of IComparable.Employee).CompareTo
      Return Me.employeeID.CompareTo(rhs.employeeID)
   End Function

End Class
Output:
5 3 7 8 3 8 4 9 7
102 106 100 106 101 107 109 109 106

Sorted:
3 3 4 5 7 7 8 8 9
100 101 102 106 106 106 107 109 109

The output shows that the integer array and Employee array were generated with random numbers. When sorted, the display shows the values have been ordered properly.

Dictionaries implement the IDictionary<K,V> interface (where K is the key type and V is the value type).

Example 17-7 demonstrates adding items to a Dictionary and then retrieving them.

Module Module1

    Sub Main()
      Dim dict As Dictionary(Of String, String) = New Dictionary(Of String, String)
      dict.Add("Alabama", "Montgomery")
      dict.Add("Alaska", "Juneau")
      dict.Add("Arizona", "Phoenix")
      dict.Add("Arkansas", "Little Rock")
      dict.Add("California", "Sacramento")
      dict.Add("Colorado", "Denver")
      dict.Add("Connecticut", "Hartford")
      dict.Add("Delaware", "Dover")
      dict.Add("Florida", "Tallahassee")
      dict.Add("Georgia", "Atlanta")
      dict.Add("Hawaii", "Honolulu")
      dict.Add("Idaho", "Boise")
      dict.Add("Illinois", "Springfield")
      dict.Add("Iowa", "Des Moines")
      dict.Add("Kansas", "Topeka")
      dict.Add("Kentucky", "Frankfort")
      dict.Add("Louisiana", "Baton Rouge")
      dict.Add("Maine", "Augusta")
      dict.Add("Maryland", "Anapolis")
      dict.Add("Massachusetts", "Boston")
      dict.Add("Michigan", "Lansing")
      dict.Add("Minnesota", "St. Paul")
      dict.Add("Mississippi", "Jackson")
      dict.Add("Missouri", "Jefferson City")
      dict.Add("Montana", "Helena")
      dict.Add("Nebraska", "Lincoln")
      dict.Add("Nevada", "Carson City")
      dict.Add("New Hampshire", "Concord")
      dict.Add("New Jersey", "Trenton")
      dict.Add("New Mexico", "Santa Fe")
      dict.Add("New York", "Albany")
      dict.Add("North Carolina", "Raleigh")
      dict.Add("North Dakota", "Bismark")
      dict.Add("Ohio", "Columbus")
      dict.Add("Oklahoma", "Oklahoma City")
      dict.Add("Oregon", "Salem")
      dict.Add("Pennsylvania", "Harrisburg")
      dict.Add("Rhode Island", "Providence")
      dict.Add("South Carolina", "Columbia")
      dict.Add("South Dakota", "Pierre")
      dict.Add("Tennessee", "Nashville")
      dict.Add("Texas", "Austin")
      dict.Add("Utah", "Salt Lake City")
      dict.Add("Vermont", "Montpelier")
      dict.Add("Washington", "Olympia")
      dict.Add("West Virginia", "Charleston")
      dict.Add("Wisconsin", "Madison")
      dict.Add("Wyoming", "Cheyenne")

      ' access a state
      Console.WriteLine("The capital of Massachusetts is {0}", _
         dict("Massachusetts"))
    End Sub
End Module

Output:
The capital of Massachussetts is Boston

Example 17-7 begins by instantiating a new Dictionary. The key and the value are both declared to be strings.

I got a bit carried away and added the key/value pairs for all 50 states. The key is the state name, the value is the capital (often the values associated with a key will be more complex than simple strings) then accessed the capital of Massachusetts, using the string Massachusetts as the key, and retrieving the string Boston as the value.