The following code shows how you might create an array of integers. The parentheses and the number 8 mean this should be an array with bounds 0 and 8, giving it 9 items.

Dim values(8) As Integer

You can optionally include the phrase "0 To" before the upper bound to emphasize the fact that array has 0 for its lower bound, as in the following code:

Dim values(0 To 8) As Integer

Alternatively, you can declare an array without giving it an upper bound. Later you can use the ReDim statement to redimension the array and give it bounds. For example, the following code declares an array of strings named employees. Later it uses ReDim to give the array 100 entries.

Dim employees() As String
...
ReDim employees(0 To 99)

If you include the optional Preserve keyword, then the array retains any old values when it resizes. If you don't include Preserve, then all of the entries in the array are reset to default values such as 0 for numbers and a blank string for strings.

For example, the following code shrinks the employees array to hold only 50 values, keeping the entries in positions 0 through 49:

ReDim Preserve employees(0 To 49)

After you have created an array, you can access its members by using the array's name followed by an index inside parentheses. For example, the following code initializes the values array by setting the Nth entry equal to N squared:

values(0) = 0 * 0
values(1) = 1 * 1
values(2) = 2 * 2
values(3) = 3 * 3
values(4) = 4 * 4
values(5) = 5 * 5
values(6) = 6 * 6
values(7) = 7 * 7
values(8) = 8 * 8

After you have placed values in an array, you can read the values using the same parentheses syntax. The following code displays a message box that uses one of the array's values:

MessageBox.Show("7 * 7 is " & values(7).ToString())

To make initializing arrays easier, Visual Basic provides an abbreviated syntax that lets you declare an array and set its values all in one statement. Simply set the variable equal to the values you want separated by commas and surrounded by braces, as shown in the following code:

Dim values() As Integer = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34}

Note that you cannot include an upper bound when you initialize an array in this way. Visual Basic figures out the upper bound based on the number of values you provide.

FIBONACCI ARRAY

The Fibonacci program shown in Figure 16-2 (and available as part of this lesson's code download) uses an array to display Fibonacci numbers. The Nth Fibonacci number Fib(N) is defined by the equations:

• Fib(0) = 0

• Fib(1) = 1

• Fib(N) = Fib(N – 1) + Fib(N – 2)

Figure 16.2. FIGURE 16-2

The first few Fibonacci values are 0, 1, 1, 2, 3, 5, 8, 13, 21.

Use the program's NumericUpDown control to select a number and click Calculate to see the corresponding Fibonacci number.

When the user clicks Calculate, the program executes the following code:

' Display a Fibonacci number.
Private Sub btnCalculate_Click() Handles btnCalculate.Click
    Dim values(0 To 20) As Integer
    values(0) = 0
    values(1) = 1
    values(2) = values(0) + values(1)
    values(3) = values(1) + values(2)
    ...

    Dim index As Integer = CInt(nudIndex.Value)
    txtResult.Text = values(index).ToString()
End Sub

The code starts by initializing the values array to hold the first 21 Fibonacci numbers. It uses the following definition of the numbers to calculate the values:

Fibonacci(i) = Fibonacci(i - 1) + Fibonacci(i - 2)

After initializing the array, the program gets the value selected by the NumericUpDown control, converts it from a Decimal to an Integer, uses it as an index into the values array, and displays the result in txtResult.

The arrays described in the previous section hold a single row of items but Visual Basic also enables you to define multi-dimensional arrays. You can think of these as higher dimensional sequences of apartment mailboxes.

Figure 16-3 shows a graphic representation of a two-dimensional array with four rows and eight columns.

Figure 16.3. FIGURE 16-3

The following code shows how you could declare, allocate, and initialize this array to hold a multiplication table with values up to 3 times 7:

Dim values(0 To 3, 0 To 7) As Integer
values(0, 0) = 0 * 0
values(0, 1) = 0 * 1
values(0, 2) = 0 * 2
...
values(1, 0) = 1 * 0
values(1, 1) = 1 * 1
...
values(3, 7) = 3 * 7

The following code shows the Visual Basic syntax for quickly defining and initializing a two-dimensional array:

Dim values(,) As Integer =
{
    {0, 1, 2},
    {3, 4, 5},
    {6, 7, 8}
}

You can use similar syntax to make and initialize even higher-dimensional arrays. For example, the following code makes a four-dimensional array of strings:

Dim employeeData(0 To 9, 0 To 19, 0 To 29, 0 To 39) As String

All arrays have a Length property that your code can use to determine the number of items in the array. All arrays have a lower bound of 0, so for one-dimensional arrays, Length – 1 gives an array's upper bound.

Arrays also have GetLowerBound and GetUpperBound methods that return the lower and upper bounds, respectively, for a particular dimension in an array.

For example, the following code creates a 5-by-10 array. It then displays the lower and upper bounds for the two dimensions. (As usual, the dimension numbers start at 0.)

Dim x(4, 9) As Integer
MessageBox.Show("The first dimension runs from " &
    x.GetLowerBound(0) & " to " & x.GetUpperBound(0))
MessageBox.Show("The second dimension runs from " &
    x.GetLowerBound(1) & " to " & x.GetUpperBound(1))

The Array class also provides several useful static methods that you can use to manipulate arrays. For example, the following code sorts the array named salaries:

Array.Sort(salaries)

The Sort method has many overloaded versions that perform different kinds of sorting. For example, instead of passing it a single array, you can pass it an array of keys and an array of items. In that case the method sorts the keys, moving the items so they remain matched up with their corresponding keys.

Table 16-1 summarizes the most useful methods provided by the Array class.

The following sections describe some particular kinds of classes that are included pre-built by the .NET Framework. These are generic classes so before you learn about them you should know a little about what a generic class is.

A generic class is one that is not tied to a particular data type. For example, suppose you built a StringList class that can store a list of strings. Now suppose you decided you wanted an IntegerList class to store lists of integers. The two classes would be practically identical, just for different data types.

I've mentioned several times that duplicated code is a bad thing. Having two nearly identical classes means debugging and maintaining two different sets of code that are practically the same.

One solution to this dilemma is to make a more general AnythingList class that uses the general Object data type to store items. An Object can hold any kind of data, so this class could hold lists of integers, strings, or Customer objects. Unfortunately, this solution has two big problems.

First, you would do a lot of work converting the items with the general Object data type stored in the list into the Integer, String, or Customer type of the items that you put in there. This is annoying because it gives you more work to do, and it makes your code more complicated and harder to read.

A bigger problem is that a list that can hold anything can hold anything. If you make a list intended to hold customer data, it could still hold Integers, Strings, and PurchaseOrder objects. Your code would need to do a lot of work to protect against potentially invalid data.

A much better approach is to use generic classes. These classes take data types in their declarations so they know what kind of data they will manipulate. Using this kind of class, you can use the same class to build a list of integers, strings, or what have you.

The following code declares and initializes a generic List class:

Dim names As New List(Of String)

The (Of String) part of the declaration indicates that the class will work with strings. You can put strings into the list and take strings out of it. You cannot add an integer to the list, just as you can't set a string variable equal to an integer. Visual Studio knows that the list works with strings and not with anything else.

Note that IntelliSense recognizes generic classes and provides help. If you begin a declaration with List, IntelliSense displays List(Of T) to let you know that it is a generic class.

Now, with some understanding of generic classes, you're ready to look at some generic collection classes.

A List is a simple ordered list of items. You can declare and initialize a List as shown in the following code:

Dim names As New List(Of String)

The List class provides several methods for manipulating the items it contains. The three most important are Add, Remove, and RemoveAt:

In addition to these methods, you can use parentheses to get and set a List's entries much as you can with an array. For example, the following code sets and then displays the value of the first entry in a List:

names(0) = "Mickey"
MessageBox.Show("The first name is " & names(0))

Note that this works only if the index you use exists in the List. If the list holds 10 names and you try to set the 14th, the program crashes.

A SortedList stores a list of key/value pairs, keeping the list sorted by the keys. The types of the keys and values are generic parameters; for example, you could make a list that uses numbers (such as employee IDs) for keys, and strings (such as names) for values.

Note that the list will not allow you to add two items with the same key. Multiple items can have the same value, but if you try to add two with the same key, the program crashes.

Table 16-2 summarizes useful methods provided by the SortedList class.

In addition to these methods, you can use parentheses to index into the list, using the items' keys as indexes.

The following code demonstrates a SortedList:

Dim addresses As New SortedList(Of String, String)

addresses.Add("Dan", "4 Deer Dr, Bugville VT, 01929")
addresses.Add("Bob", "8273 Birch Blvd, Bugville VT, 01928")

addresses("Cindy") = "32878 Carpet Ct, Bugville VT, 01929"
addresses("Alice") = "162 Ash Ave, Bugville VT, 01928"
addresses("Bob") = "8273 Bash Blvd, Bugville VT, 01928"

MessageBox.Show("Bob's address is " & addresses("Bob"))

The code starts by declaring and initializing the list. It uses the Add method to add some entries and then uses parentheses to add some more. Notice that the SortedList doesn't need to already contain a key before the code can set its value. In this example, there is no entry for Cindy until the code sets addresses("Cindy".

Next, the code uses the parentheses syntax to update Bob's address. Finally, the code displays Bob's new address.

You can't see it from this example, but unlike the List class, SortedList actually stores its items ordered by key. For example, you could use the GetKeyList and GetValueList methods to get the SortedList's keys and values in order.

The Dictionary and SortedDictionary classes provide features similar to the SortedList class, manipulating key/value pairs. The difference is in the data structures the three classes use to store their items.

Without getting into technical details, the result is that the three classes use different amounts of memory and work at different speeds. In general, SortedList is the slowest but takes the least memory, while Dictionary is the fastest but takes the most memory.

For small programs, the difference is insignificant. For big programs that work with thousands of entries, you might need to be more careful about picking a class. (Personally, I like Dictionary for most purposes because speed is nice, memory is relatively cheap, and the name is suggestive of the way you use the class: to look up something by key.)

A Queue is a collection that enables you to add items at one end and remove them from the other. It's like the line at a bank; you stand at the back of the line and the teller helps the person at the front of the line until eventually it's your turn.

Table 16-3 summarizes the Queue's most important methods.

A Stack is a collection that enables you to add items at one end and remove them from the same end. It's like a stack of books on the floor: You can add a book to the top of the stack and remove a book from the top, but you can't pull one out of the middle or bottom without risking a collapse.

Table 16-4 summarizes the Stack's most important methods.

In this lesson: