8/29/2019 Arrays in Visual Basic | Microsoft Docs

Arrays in Visual Basic

12/06/2017 • 28 minutes to read • +6

In this article
Array elements in a simple array
Creating an array
Storing values in an array
Populating an array with array literals
Iterating through an array
Array size
The array type
Arrays as return values and parameters
Jagged arrays
Zero-length arrays
Splitting an array
Joining arrays
Collections as an alternative to arrays
Related topics
See also

An array is a set of values, which are termed elements, that are logically related to each
other. For example, an array may consist of the number of students in each grade in a
grammar school; each element of the array is the number of students in a single grade.
Similarly, an array may consist of a student's grades for a class; each element of the array is
a single grade.

It is possible individual variables to store each of our data items. For example, if our
application analyzes student grades, we can use a separate variable for each student's
grade, such as englishGrade1 , englishGrade2 , etc. This approach has three major
limitations:

We have to know at design time exactly how many grades we have to handle.
Handling large numbers of grades quickly becomes unwieldy. This in turn makes an
application much more likely to have serious bugs.
It is difficult to maintain. Each new grade that we add requires that the application be
modified, recompiled, and redeployed.

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 1/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

By using an array, you can refer to these related values by the same name, and use a
number that’s called an index or subscript to identify an individual element based on its
position in the array. The indexes of an array range from 0 to one less than the total
number of elements in the array. When you use Visual Basic syntax to define the size of an
array, you specify its highest index, not the total number of elements in the array. You can
work with the array as a unit, and the ability to iterate its elements frees you from needing
to know exactly how many elements it contains at design time.

Some quick examples before explanation:

VB ＝ Copy

' Declare a single-dimension array of 5 numbers.

Dim numbers(4) As Integer

' Declare a single-dimension array and set its 4 values.

Dim numbers = New Integer() {1, 2, 4, 8}

' Change the size of an existing array to 16 elements and retain the current
values.
ReDim Preserve numbers(15)

' Redefine the size of an existing array and reset the values.
ReDim numbers(15)

' Declare a 6 x 6 multidimensional array.

Dim matrix(5, 5) As Double

' Declare a 4 x 3 multidimensional array and set array element values.

Dim matrix = New Integer(3, 2) {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}

' Declare a jagged array

Dim sales()() As Double = New Double(11)() {}

Array elements in a simple array

Let's create an array named students to store the number of students in each grade in a
grammar school. The indexes of the elements range from 0 through 6. Using this array is
simpler than declaring seven variables.

The following illustration shows the students array. For each element of the array:

The index of the element represents the grade (index 0 represents kindergarten).

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 2/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

The value that’s contained in the element represents the number of students in that
grade.

The following example contains the Visual Basic code that creates and uses the array:

VB ＝ Copy

Module SimpleArray
Public Sub Main()
' Declare an array with 7 elements.
Dim students(6) As Integer

' Assign values to each element.

students(0) = 23
students(1) = 19
students(2) = 21
students(3) = 17
students(4) = 19
students(5) = 20
students(6) = 22

' Display the value of each element.

For ctr As Integer = 0 To 6
Dim grade As String = If(ctr = 0, "kindergarten", $"grade {ctr}")
Console.WriteLine($"Students in {grade}: {students(ctr)}")
Next
End Sub
End Module
' The example displays the following output:
' Students in kindergarten: 23
' Students in grade 1: 19
' Students in grade 2: 21
' Students in grade 3: 17
' Students in grade 4: 19
' Students in grade 5: 20
' Students in grade 6: 22

The example does three things:

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 3/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

It declares a students array with seven elements. The number 6 in the array
declaration indicates the last index in the array; it is one less than the number of
elements in the array.
It assigns values to each element in the array. Array elements are accessed by using
the array name and including the index of the individual element in parentheses.
It lists each value of the array. The example uses a For statement to access each
element of the array by its index number.

The students array in the preceding example is a one-dimensional array because it uses
one index. An array that uses more than one index or subscript is called multidimensional.
For more information, see the rest of this article and Array Dimensions in Visual Basic.

Creating an array
You can define the size of an array in several ways:

You can specify the size when the array is declared:

VB ＝ Copy

' Declare an array with 10 elements.

Dim cargoWeights(9) As Double
' Declare a 24 x 2 array.
Dim hourlyTemperatures(23, 1) As Integer
' Declare a jagged array with 31 elements.
Dim januaryInquiries(30)() As String

You can use a New clause to supply the size of an array when it’s created:

VB ＝ Copy

' Declare an array with 10 elements.

Dim cargoWeights() As Double = New Double(9) {}
' Declare a 24 x 2 array.
Dim hourlyTemperatures(,) As Integer = New Integer(23, 1) {}
' Declare a jagged array with 31 elements.
Dim januaryInquiries()() As String = New String(30)() {}

If you have an existing array, you can redefine its size by using the ReDim statement. You
can specify that the ReDim statement keep the values that are in the array, or you can
specify that it create an empty array. The following example shows different uses of the
ReDim statement to modify the size of an existing array.

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 4/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

VB ＝ Copy

' Assign a new array size and retain the current values.
ReDim Preserve cargoWeights(20)
' Assign a new array size and retain only the first five values.
ReDim Preserve cargoWeights(4)
' Assign a new array size and discard all current element values.
ReDim cargoWeights(15)

For more information, see the ReDim Statement.

Storing values in an array

You can access each location in an array by using an index of type Integer . You can store
and retrieve values in an array by referencing each array location by using its index
enclosed in parentheses. Indexes for multidimensional arrays are separated by commas (,).
You need one index for each array dimension.

The following example shows some statements that store and retrieve values in arrays.

VB ＝ Copy

Module Example
Public Sub Main()
' Create a 10-element integer array.
Dim numbers(9) As Integer
Dim value As Integer = 2

' Write values to it.

For ctr As Integer = 0 To 9
numbers(ctr) = value
value *= 2
Next

' Read and sum the array values.

Dim sum As Integer
For ctr As Integer = 0 To 9
sum += numbers(ctr)
Next
Console.WriteLine($"The sum of the values is {sum:N0}")
End Sub
End Module
' The example displays the following output:
' The sum of the values is 2,046

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 5/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

Populating an array with array literals

By using an array literal, you can populate an array with an initial set of values at the same
time that you create it. An array literal consists of a list of comma-separated values that are
enclosed in braces ( {} ).

When you create an array by using an array literal, you can either supply the array type or
use type inference to determine the array type. The following example shows both options.

VB ＝ Copy

' Array literals with explicit type definition.

Dim numbers = New Integer() {1, 2, 4, 8}
' Array literals with type inference.
Dim doubles = {1.5, 2, 9.9, 18}
' Array literals with explicit type definition.
Dim articles() As String = { "the", "a", "an" }

' Array literals with explicit widening type definition.

Dim values() As Double = { 1, 2, 3, 4, 5 }

When you use type inference, the type of the array is determined by the dominant type in
the list of literal values. The dominant type is the type to which all other types in the array
can widen. If this unique type can’t be determined, the dominant type is the unique type to
which all other types in the array can narrow. If neither of these unique types can be
determined, the dominant type is Object . For example, if the list of values that’s supplied
to the array literal contains values of type Integer , Long , and Double , the resulting array is
of type Double . Because Integer and Long widen only to Double , Double is the dominant
type. For more information, see Widening and Narrowing Conversions.

７ Note

You can use type inference only for arrays that are defined as local variables in a type
member. If an explicit type definition is absent, arrays defined with array literals at the
class level are of type Object[] . For more information, see Local type inference.

Note that the previous example defines values as an array of type Double even though all
the array literals are of type Integer . You can create this array because the values in the
array literal can widen to Double values.

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 6/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

You can also create and populate a multidimensional array by using nested array literals.
Nested array literals must have a number of dimensions that’s consistent with the resulting
array. The following example creates a two-dimensional array of integers by using nested
array literals.

VB ＝ Copy

' Create and populate a 2 x 2 array.

Dim grid1 = {{1, 2}, {3, 4}}
' Create and populate a 2 x 2 array with 3 elements.
Dim grid2(,) = {{1, 2}, {3, 4}, {5, 6}}

When using nested array literals to create and populate an array, an error occurs if the
number of elements in the nested array literals don't match. An error also occurs if you
explicitly declare the array variable to have a different number of dimensions than the array
literals.

Just as you can for one-dimensional arrays, you can rely on type inference when creating a
multidimensional array with nested array literals. The inferred type is the dominant type for
all the values in all the array literals for all nesting level. The following example creates a
two-dimensional array of type Double[,] from values that are of type Integer and Double .

VB ＝ Copy

Dim arr = {{1, 2.0}, {3, 4}, {5, 6}, {7, 8}}

For additional examples, see How to: Initialize an Array Variable in Visual Basic.

Iterating through an array

When you iterate through an array, you access each element in the array from the lowest
index to the highest or from the highest to the lowest. Typically, use either the For...Next
Statement or the For Each...Next Statement to iterate through the elements of an array.
When you don't know the upper bounds of the array, you can call the
Array.GetUpperBound method to get the highest value of the index. Although lowest index
value is almost always 0, you can call the Array.GetLowerBound method to get the lowest
value of the index.

The following example iterates through a one-dimensional array by using the For...Next
statement.

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 7/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

VB ＝ Copy

Module IterateArray
Public Sub Main()
Dim numbers = {10, 20, 30}

For index = 0 To numbers.GetUpperBound(0)

Console.WriteLine(numbers(index))
Next
End Sub
End Module
' The example displays the following output:
' 10
' 20
' 30

The following example iterates through a multidimensional array by using a For...Next

statement. The GetUpperBound method has a parameter that specifies the dimension.
GetUpperBound(0) returns the highest index of the first dimension, and GetUpperBound(1)
returns the highest index of the second dimension.

VB ＝ Copy

Module IterateArray
Public Sub Main()
Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

For index0 = 0 To numbers.GetUpperBound(0)

For index1 = 0 To numbers.GetUpperBound(1)
Console.Write($"{numbers(index0, index1)} ")
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' Output
' 1 2
' 3 4
' 5 6

The following example uses a For Each...Next Statementto iterate through a one-
dimensional array and a two-dimensional array.

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 8/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

VB ＝ Copy

Module IterateWithForEach
Public Sub Main()
' Declare and iterate through a one-dimensional array.
Dim numbers1 = {10, 20, 30}

For Each number In numbers1

Console.WriteLine(number)
Next
Console.WriteLine()

Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

For Each number In numbers

Console.WriteLine(number)
Next
End Sub
End Module
' The example displays the following output:
' 10
' 20
' 30
'
' 1
' 2
' 3
' 4
' 5
' 6

Array size
The size of an array is the product of the lengths of all its dimensions. It represents the
total number of elements currently contained in the array. For example, the following
example declares a 2-dimensional array with four elements in each dimension. As the
output from the example shows, the array's size is 16 (or (3 + 1) * (3 + 1).

VB ＝ Copy

Module Example
Public Sub Main()
Dim arr(3, 3) As Integer
Console.WriteLine(arr.Length)
End Sub
https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 9/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

End Module
' The example displays the following output:
' 16

７ Note

This discussion of array size does not apply to jagged arrays. For information on
jagged arrays and determining the size of a jagged array, see the Jagged arrays
section.

You can find the size of an array by using the Array.Length property. You can find the
length of each dimension of a multidimensional array by using the Array.GetLength
method.

You can resize an array variable by assigning a new array object to it or by using the ReDim
Statement statement. The following example uses the ReDim statement to change a 100-
element array to a 51-element array.

VB ＝ Copy

Module Example
Public Sub Main()
Dim arr(99) As Integer
Console.WriteLine(arr.Length)

Redim arr(50)
Console.WriteLine(arr.Length)
End Sub
End Module
' The example displays the following output:
' 100
' 51

There are several things to keep in mind when dealing with the size of an array.

Dimension The index of each dimension is 0-based, which means it ranges from 0 to its
Length upper bound. Therefore, the length of a given dimension is one greater than the
declared upper bound of that dimension.

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 10/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

Length Limits The length of every dimension of an array is limited to the maximum value of
the Integer data type, which is Int32.MaxValue or (2 ^ 31) - 1. However, the
total size of an array is also limited by the memory available on your system. If
you attempt to initialize an array that exceeds the amount of available memory,
the runtime throws an OutOfMemoryException.

Size and An array's size is independent of the data type of its elements. The size always
Element Size represents the total number of elements, not the number of bytes that they
consume in memory.

Memory It is not safe to make any assumptions regarding how an array is stored in
Consumption memory. Storage varies on platforms of different data widths, so the same array
can consume more memory on a 64-bit system than on a 32-bit system.
Depending on system configuration when you initialize an array, the common
language runtime (CLR) can assign storage either to pack elements as close
together as possible, or to align them all on natural hardware boundaries. Also,
an array requires a storage overhead for its control information, and this
overhead increases with each added dimension.

The array type

Every array has a data type, which differs from the data type of its elements. There is no
single data type for all arrays. Instead, the data type of an array is determined by the
number of dimensions, or rank, of the array, and the data type of the elements in the array.
Two array variables are of the same data type only when they have the same rank and their
elements have the same data type. The lengths of the dimensions of an array do not
influence the array data type.

Every array inherits from the System.Array class, and you can declare a variable to be of
type Array , but you cannot create an array of type Array . For example, although the
following code declares the arr variable to be of type Array and calls the
Array.CreateInstance method to instantiate the array, the array's type proves to be Object[].

VB ＝ Copy

Module Example
Public Sub Main()
Dim arr As Array = Array.CreateInstance(GetType(Object), 19)
Console.WriteLine(arr.Length)
Console.WriteLine(arr.GetType().Name)

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 11/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

End Sub
End Module
' The example displays the following output:
' 19
' Object[]

Also, the ReDim Statement cannot operate on a variable declared as type Array . For these
reasons, and for type safety, it is advisable to declare every array as a specific type.

You can find out the data type of either an array or its elements in several ways.

You can call the GetType method on the variable to get a Type object that represents
the run-time type of the variable. The Type object holds extensive information in its
properties and methods.
You can pass the variable to the TypeName function to get a String with the name of
run-time type.

The following example calls the both the GetType method and the TypeName function to
determine the type of an array. The array type is Byte(,) . Note that the Type.BaseType
property also indicates that the base type of the byte array is the Array class.

VB ＝ Copy

Module Example
Public Sub Main()
Dim bytes(9,9) As Byte
Console.WriteLine($"Type of {nameof(bytes)} array:
{bytes.GetType().Name}")
Console.WriteLine($"Base class of {nameof(bytes)}:
{bytes.GetType().BaseType.Name}")
Console.WriteLine()
Console.WriteLine($"Type of {nameof(bytes)} array: {TypeName(bytes)}")
End Sub
End Module
' The example displays the following output:
' Type of bytes array: Byte[,]
' Base class of bytes: Array
'
' Type of bytes array: Byte(,)

Arrays as return values and parameters

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 12/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

To return an array from a Function procedure, specify the array data type and the number
of dimensions as the return type of the Function Statement. Within the function, declare a
local array variable with same data type and number of dimensions. In the Return
Statement, include the local array variable without parentheses.

To specify an array as a parameter to a Sub or Function procedure, define the parameter

as an array with a specified data type and number of dimensions. In the call to the
procedure, pass an array variable with the same data type and number of dimensions.

In the following example, the GetNumbers function returns an Integer() , a one-dimensional

array of type Integer . The ShowNumbers procedure accepts an Integer() argument.

VB ＝ Copy

Module ReturnValuesAndParams
Public Sub Main()
Dim numbers As Integer() = GetNumbers()
ShowNumbers(numbers)
End Sub

Private Function GetNumbers() As Integer()

Dim numbers As Integer() = {10, 20, 30}
Return numbers
End Function

Private Sub ShowNumbers(numbers As Integer())

For index = 0 To numbers.GetUpperBound(0)
Console.WriteLine($"{numbers(index)} ")
Next
End Sub
End Module
' The example displays the following output:
' 10
' 20
' 30

In the following example, the GetNumbersMultiDim function returns an Integer(,) , a two-

dimensional array of type Integer . The ShowNumbersMultiDim procedure accepts an
Integer(,) argument.

VB ＝ Copy

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 13/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

Module Example
Public Sub Main()
Dim numbers As Integer(,) = GetNumbersMultidim()
ShowNumbersMultidim(numbers)
End Sub

Private Function GetNumbersMultidim() As Integer(,)

Dim numbers As Integer(,) = {{1, 2}, {3, 4}, {5, 6}}
Return numbers
End Function

Private Sub ShowNumbersMultidim(numbers As Integer(,))

For index0 = 0 To numbers.GetUpperBound(0)
For index1 = 0 To numbers.GetUpperBound(1)
Console.Write($"{numbers(index0, index1)} ")
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' 1 2
' 3 4
' 5 6

Jagged arrays
Sometimes the data structure in your application is two-dimensional but not rectangular.
For example, you might use an array to store data about the high temperature of each day
of the month. The first dimension of the array represents the month, but the second
dimension represents the number of days, and the number of days in a month is not
uniform. A jagged array, which is also called an array of arrays, is designed for such
scenarios. A jagged array is an array whose elements are also arrays. A jagged array and
each element in a jagged array can have one or more dimensions.

The following example uses an array of months, each element of which is an array of days.
The example uses a jagged array because different months have different numbers of days.
The example shows how to create a jagged array, assign values to it, and retrieve and
display its values.

VB ＝ Copy

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 14/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

Imports System.Globalization

Module JaggedArray
Public Sub Main()
' Declare the jagged array of 12 elements. Each element is an array of
Double.
Dim sales(11)() As Double
' Set each element of the sales array to a Double array of the
appropriate size.
For month As Integer = 0 To 11
' The number of days in the month determines the appropriate size.
Dim daysInMonth As Integer =
DateTime.DaysInMonth(Year(Now), month + 1)
sales(month) = New Double(daysInMonth - 1) {}
Next

' Store values in each element.

For month As Integer = 0 To 11
For dayOfMonth = 0 To sales(month).GetUpperBound(0)
sales(month)(dayOfMonth) = (month * 100) + dayOfMonth
Next
Next

' Retrieve and display the array values.

Dim monthNames = DateTimeFormatInfo.CurrentInfo.AbbreviatedMonthNames
' Display the month names.
Console.Write(" ")
For ctr = 0 To sales.GetUpperBound(0)
Console.Write($" {monthNames(ctr)} ")
Next
Console.WriteLine()
' Display data for each day in each month.
For dayInMonth = 0 To 30
Console.Write($"{dayInMonth + 1,2}. ")
For monthNumber = 0 To sales.GetUpperBound(0)
If dayInMonth > sales(monthNumber).GetUpperBound(0) Then
Console.Write(" ")
Else
Console.Write($"{sales(monthNumber)(dayInMonth),-5} ")
End If
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' Jan Feb Mar Apr May Jun Jul Aug Sep Oct
Nov Dec
' 1. 0 100 200 300 400 500 600 700 800 900
1000 1100

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 15/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

' 2. 1 101 201 301 401 501 601 701 801 901
1001 1101
' 3. 2 102 202 302 402 502 602 702 802 902
1002 1102
' 4. 3 103 203 303 403 503 603 703 803 903
1003 1103
' 5. 4 104 204 304 404 504 604 704 804 904
1004 1104
' 6. 5 105 205 305 405 505 605 705 805 905
1005 1105
' 7. 6 106 206 306 406 506 606 706 806 906
1006 1106
' 8. 7 107 207 307 407 507 607 707 807 907
1007 1107
' 9. 8 108 208 308 408 508 608 708 808 908
1008 1108
' 10. 9 109 209 309 409 509 609 709 809 909
1009 1109
' 11. 10 110 210 310 410 510 610 710 810 910
1010 1110
' 12. 11 111 211 311 411 511 611 711 811 911
1011 1111
' 13. 12 112 212 312 412 512 612 712 812 912
1012 1112
' 14. 13 113 213 313 413 513 613 713 813 913
1013 1113
' 15. 14 114 214 314 414 514 614 714 814 914
1014 1114
' 16. 15 115 215 315 415 515 615 715 815 915
1015 1115
' 17. 16 116 216 316 416 516 616 716 816 916
1016 1116
' 18. 17 117 217 317 417 517 617 717 817 917
1017 1117
' 19. 18 118 218 318 418 518 618 718 818 918
1018 1118
' 20. 19 119 219 319 419 519 619 719 819 919
1019 1119
' 21. 20 120 220 320 420 520 620 720 820 920
1020 1120
' 22. 21 121 221 321 421 521 621 721 821 921
1021 1121
' 23. 22 122 222 322 422 522 622 722 822 922
1022 1122
' 24. 23 123 223 323 423 523 623 723 823 923
1023 1123
' 25. 24 124 224 324 424 524 624 724 824 924
1024 1124
' 26. 25 125 225 325 425 525 625 725 825 925
1025 1125
' 27. 26 126 226 326 426 526 626 726 826 926

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 16/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

1026 1126
' 28. 27 127 227 327 427 527 627 727 827 927
1027 1127
' 29. 28 228 328 428 528 628 728 828 928
1028 1128
' 30. 29 229 329 429 529 629 729 829 929
1029 1129
' 31. 30 230 430 630 730 930
1130

The previous example assigns values to the jagged array on an element-by-element basis
by using a For...Next loop. You can also assign values to the elements of a jagged array
by using nested array literals. However, the attempt to use nested array literals (for
example, Dim valuesjagged = {{1, 2}, {2, 3, 4}} ) generates compiler error BC30568. To
correct the error, enclose the inner array literals in parentheses. The parentheses force the
array literal expression to be evaluated, and the resulting values are used with the outer
array literal, as the following example shows.

VB ＝ Copy

Module Example
Public Sub Main()
Dim values1d = { 1, 2, 3 }
Dim values2d = {{1, 2}, {2, 3}, {3, 4}}
Dim valuesjagged = {({1, 2}), ({2, 3, 4})}
End Sub
End Module

A jagged array is a one-dimensional array whose elements contain arrays. Therefore, the
Array.Length property and the Array.GetLength(0) method return the number of elements
in the one-dimensional array, and Array.GetLength(1) throws an
IndexOutOfRangeException because a jagged array is not multidimensional. You determine
the number of elements in each subarray by retrieving the value of each subarray's
Array.Length property. The following example illustrates how to determine the number of
elements in a jagged array.

VB ＝ Copy

Module Example
Public Sub Main()
Dim jagged = { ({1, 2}), ({2, 3, 4}), ({5, 6}), ({7, 8, 9, 10}) }

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 17/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

Console.WriteLine($"The value of jagged.Length: {jagged.Length}.")

Dim total = jagged.Length
For ctr As Integer = 0 To jagged.GetUpperBound(0)
Console.WriteLine($"Element {ctr + 1} has {jagged(ctr).Length}
elements.")
total += jagged(ctr).Length
Next
Console.WriteLine($"The total number of elements in the jagged array:
{total}")
End Sub
End Module
' The example displays the following output:
' The value of jagged.Length: 4.
' Element 1 has 2 elements.
' Element 2 has 3 elements.
' Element 3 has 2 elements.
' Element 4 has 4 elements.
' The total number of elements in the jagged array: 15

Zero-length arrays
Visual Basic differentiates between a uninitialized array (an array whose value is Nothing )
and a zero-length array or empty array (an array that has no elements.) An uninitialized
array is one that has not been dimensioned or had any values assigned to it. For example:

VB ＝ Copy

Dim arr() As String

A zero-length array is declared with a dimension of -1. For example:

VB ＝ Copy

Dim arrZ(-1) As String

You might need to create a zero-length array under the following circumstances:

Without risking a NullReferenceException exception, your code must access members

of the Array class, such as Length or Rank, or call a Visual Basic function such as
UBound.

You want to keep your code simple by not having to check for Nothing as a special
case.
https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 18/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

Your code interacts with an application programming interface (API) that either
requires you to pass a zero-length array to one or more procedures or returns a zero-
length array from one or more procedures.

Splitting an array
In some cases, you may need to split a single array into multiple arrays. This involves
identifying the point or points at which the array is to be split, and then spitting the array
into two or more separate arrays.

７ Note

This section does not discuss splitting a single string into a string array based on some
delimiter. For information on splitting a string, see the String.Split method.

The most common criteria for splitting an array are:

The number of elements in the array. For example, you might want to split an array of
more than a specified number of elements into a number of approximately equal
parts. For this purpose, you can use the value returned by either the Array.Length or
Array.GetLength method.

The value of an element, which serves as a delimiter that indicates where the array
should be split. You can search for a specific value by calling the Array.FindIndex and
Array.FindLastIndex methods.

Once you've determined the index or indexes at which the array should be split, you can
then create the individual arrays by calling the Array.Copy method.

The following example splits an array into two arrays of approximately equal size. (If the
total number of array elements is odd, the first array has one more element than the
second.)

VB ＝ Copy

Module Example
Public Sub Main()
' Create an array of 100 elements.
Dim arr(99) As Integer
' Populate the array.
Dim rnd As new Random()
https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 19/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

For ctr = 0 To arr.GetUpperBound(0)

arr(ctr) = rnd.Next()
Next

' Determine how many elements should be in each array.

Dim divisor = 2
Dim remainder As Integer
Dim boundary = Math.DivRem(arr.GetLength(0), divisor, remainder)

' Copy the array.

Dim arr1(boundary - 1 + remainder), arr2(boundary - 1) as Integer
Array.Copy(arr, 0, arr1, 0, boundary + remainder)
Array.Copy(arr, boundary + remainder, arr2, 0, arr.Length - boundary)
End Sub
End Module

The following example splits a string array into two arrays based on the presence of an
element whose value is "zzz", which serves as the array delimiter. The new arrays do not
include the element that contains the delimiter.

VB ＝ Copy

Module Example
Public Sub Main()
Dim rnd As New Random()

' Create an array of 100 elements.

Dim arr(99) As String
' Populate each element with an arbitrary ASCII character.
For ctr = 0 To arr.GetUpperBound(0)
arr(ctr) = ChrW(Rnd.Next(&h21, &h7F))
Next
' Get a random number that will represent the point to insert the
delimiter.
arr(rnd.Next(0, arr.GetUpperBound(0))) = "zzz"

' Find the delimiter.

Dim location = Array.FindIndex(arr, Function(x) x = "zzz")

' Create the arrays.

Dim arr1(location - 1) As String
Dim arr2(arr.GetUpperBound(0) - location - 1) As String

' Populate the two arrays.

Array.Copy(arr, 0, arr1, 0, location)
Array.Copy(arr, location + 1, arr2, 0, arr.GetUpperBound(0) - location)
End Sub

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 20/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

End Module

Joining arrays
You can also combine a number of arrays into a single larger array. To do this, you also use
the Array.Copy method.

７ Note

This section does not discuss joining a string array into a single string. For information
on joining a string array, see the String.Join method.

Before copying the elements of each array into the new array, you must first ensure that
you have initialized the array so that it is large enough to accommodate the new array. You
can do this in one of two ways:

Use the ReDim Preserve statement to dynamically expand the array before adding
new elements to it. This is the easiest technique, but it can result in performance
degradation and excessive memory consumption when you are copying large arrays.
Calculate the total number of elements needed for the new large array, then add the
elements of each source array to it.

The following example uses the second approach to add four arrays with ten elements
each to a single array.

VB ＝ Copy

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
Public Sub Main()
Dim tasks As New List(Of Task(Of Integer()))
' Generate four arrays.
For ctr = 0 To 3
Dim value = ctr
tasks.Add(Task.Run(Function()
Dim arr(9) As Integer
For ndx = 0 To arr.GetUpperBound(0)
arr(ndx) = value
Next
Return arr
https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 21/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

End Function))
Next
Task.WaitAll(tasks.ToArray())
' Compute the number of elements in all arrays.
Dim elements = 0
For Each task In tasks
elements += task.Result.Length
Next
Dim newArray(elements - 1) As Integer
Dim index = 0
For Each task In tasks
Dim n = task.Result.Length
Array.Copy(task.Result, 0, newArray, index, n)
index += n
Next
Console.WriteLine($"The new array has {newArray.Length} elements.")
End Sub
End Module
' The example displays the following output:
' The new array has 40 elements.

Since in this case the source arrays are all small, we can also dynamically expand the array
as we add the elements of each new array to it. The following example does that.

VB ＝ Copy

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
Public Sub Main()
Dim tasks As New List(Of Task(Of Integer()))
' Generate four arrays.
For ctr = 0 To 3
Dim value = ctr
tasks.Add(Task.Run(Function()
Dim arr(9) As Integer
For ndx = 0 To arr.GetUpperBound(0)
arr(ndx) = value
Next
Return arr
End Function))
Next
Task.WaitAll(tasks.ToArray())

' Dimension the target array and copy each element of each source array
to it.
Dim newArray() As Integer = {}

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 22/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

' Define the next position to copy to in newArray.

Dim index = 0
For Each task In tasks
Dim n = Task.Result.Length
ReDim Preserve newArray(newArray.GetUpperBound(0) + n)
Array.Copy(task.Result, 0, newArray, index, n)
index += n
Next
Console.WriteLine($"The new array has {newArray.Length} elements.")
End Sub
End Module
' The example displays the following output:
' The new array has 40 elements.

Collections as an alternative to arrays

Arrays are most useful for creating and working with a fixed number of strongly typed
objects. Collections provide a more flexible way to work with groups of objects. Unlike
arrays, which require that you explicitly change the size of an array with the ReDim
Statement, collections grow and shrink dynamically as the needs of an application change.

When you use ReDim to redimension an array, Visual Basic creates a new array and releases
the previous one. This takes execution time. Therefore, if the number of items you are
working with changes frequently, or you cannot predict the maximum number of items you
need, you'll usually obtain better performance by using a collection.

For some collections, you can assign a key to any object that you put into the collection so
that you can quickly retrieve the object by using the key.

If your collection contains elements of only one data type, you can use one of the classes in
the System.Collections.Generic namespace. A generic collection enforces type safety so
that no other data type can be added to it.

For more information about collections, see Collections.

Related topics
Term Definition

Array Dimensions in Visual Basic Explains rank and dimensions in arrays.

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 23/24
8/29/2019 Arrays in Visual Basic | Microsoft Docs

Term Definition

How to: Initialize an Array Variable Describes how to populate arrays with initial values.
in Visual Basic

How to: Sort An Array in Visual Shows how to sort the elements of an array
Basic alphabetically.

How to: Assign One Array to Describes the rules and steps for assigning an array to
Another Array another array variable.

Troubleshooting Arrays Discusses some common problems that arise when

working with arrays.

See also
System.Array
Dim Statement
ReDim Statement

Is this page helpful?

 Yes  No

https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/arrays/ 24/24