Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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.

1 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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.

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

2 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

' 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).

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

students in that grade.

3 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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}: {stu‐
dents(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

4 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

' Students in grade 5: 20

' Students in grade 6: 22

The example does three things:

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

5 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

' 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.

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 val‐
ues.
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

6 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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

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}

7 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

' 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.

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}}

8 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

' 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.

VB ＝ Copy

9 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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

10 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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

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

11 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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
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

12 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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
Length 0 to its upper bound. Therefore, the length of a given dimension is
one greater than the declared upper bound of that dimension.

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
Element Size size always 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

Consumption stored in 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

13 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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)
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.

14 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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

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

15 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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

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

16 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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.

17 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

VB ＝ Copy

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 appro‐
priate 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)

18 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

(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
' 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 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

' 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 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 }

20 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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

21 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

Module Example
Public Sub Main()
Dim jagged = { ({1, 2}), ({2, 3, 4}), ({5, 6}), ({7, 8, 9,
10}) }
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:

22 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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.

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.

23 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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()
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, re‐
mainder)

' 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

24 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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 in‐
sert 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
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

25 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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
End Function))
Next
Task.WaitAll(tasks.ToArray())
' Compute the number of elements in all arrays.
Dim elements = 0
For Each task In tasks

26 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

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

27 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

each source array to it.

Dim newArray() As Integer = {}
' 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.

28 de 29 8/15/20 8:40 a. m.
Arrays - Visual Basic | Microsoft Docs https://docs.microsoft.com/en-us/dotnet/visual-basic/programmi...

For more information about collections, see Collections.

Related topics
Term Definition

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

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

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
Another Array array to 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

29 de 29 8/15/20 8:40 a. m.