Arrays in VB.net – Types of Arrays in VB.net

What is Arrays in VB.net?

The Arrays in VB.net is a linear data structure that is a collection of data elements of the same type stored on a contiguous memory location.

Each data item is called an element of the array.

It is a fixed size of sequentially arranged elements in computer memory with the first element being at index 0 and the last element at index n – 1, where n represents the total number of elements in the array.

The following is an illustrated representation of similar data type elements defined in the VB.NET array data structure.

Declaring Arrays in VB.net

Declaring Arrays in VB.net by specifying the data of the elements followed by parentheses () in the VB.NET

'Declaring an Arrays'

Dim array_name As [Data_Type] ()  

In the above declaration, array_name is the name of an array, and the Data_Type represents the type of element (Integer, char, String, Decimal) that will to store contiguous data elements in the VB.NET array.

Example of Declaring Arrays in VB.net:

Now, let us see the example to declare an array in VB.net.

'Store only Integer values  
Dim num As Integer() or Dim num(5) As Integer  
'Store only String values  
Dim name As String() or Dim name(5) As String  
' Store only Double values  
Dim marks As Double()  

Types of Arrays in VB.net

There are two types of Arrays in VB.net namely:

1. Fixed Size Array in VB.net

A Fixed Size Array In VB.net is used to store a set number of elements in memory.

This indicates that the array’s size cannot be altered because the number of elements we specified in the array declaration will not change during the defining of the elements.

For example, we need to hold only 5 names in an array; it can be defined and initialized in the array such as:

Dim names( 0 to 4) As String  
names(0) = "Adones"  
names(1) = "Glenn"  
names(2) = "Jaymar"  
names(3) = "Paul"  
names(4) = "Jude"  

The above representation of the fixed array is that we have defined a string array named 0 to 4, which stores all the elements in the array from 0 to index 4.

2. Dynamic Arrays In VB.net

Dynamic Arrays In VB.net are those that can be resized and dimensioned in accordance with the requirements of the software.

Using the ReDim statement, a dynamic array can be declared.

Syntax for ReDim statement:

'syntax for ReDim statement'

ReDim [Preserve] arrayname(subscripts)

Example program of Dynamic Arrays in VB.net:

Module arrayApl
   Sub Main()
      Dim marks() As Integer
      Dim i As Integer
      
      ReDim marks(2)
      marks(0) = 85
      marks(1) = 75
      marks(2) = 90
     
      ReDim Preserve marks(10)
      marks(3) = 80
      marks(4) = 76
      marks(5) = 92
      marks(6) = 99
      marks(7) = 79
      marks(8) = 75
      
      For i = 0 To 10
         Console.WriteLine(i & vbTab & marks(i))
      Next i
      Console.ReadKey()
   End Sub
End Module

When the above code is compiled and executed, it produces the following result:

0 85
1 75
2 90
3 80
4 76
5 92
6 99
7 79
8 75
9 0
10 0

You can test the above example here! ➡ VB.net Online Compiler

Jagged Array in VB.net

A Jagged Array in VB.net is an array whose components are arrays of various shapes and sizes.

A jagged array can store arrays instead of a specific data type value and is occasionally referred to as an “array of arrays“.

The following code shows declaring a Jagged Array in VB.net named scores of Integers:

'Declaring a Jagged Array'

Dim scores As Integer()() = New Integer(5)(){}

Example Program of Jagged Array in VB.net

The following example illustrates using a jagged array:

Module arrayApl
   Sub Main()
      'a jagged array of 5 array of integers
      Dim a As Integer()() = New Integer(4)() {}
      a(0) = New Integer() {0, 0}
      a(1) = New Integer() {1, 2}
      a(2) = New Integer() {2, 4}
      a(3) = New Integer() {3, 6}
      a(4) = New Integer() {4, 8}
      Dim i, j As Integer
      ' output each array element's value 
      
      For i = 0 To 4
         For j = 0 To 1
            Console.WriteLine("a[{0},{1}] = {2}", i, j, a(i)(j))
         Next j
      Next i
      Console.ReadKey()
   End Sub
End Module

When the above code is compiled and executed, it produces the following result:

a[0,0] = 0
a[0,1] = 0
a[1,0] = 1
a[1,1] = 2
a[2,0] = 2
a[2,1] = 4
a[3,0] = 3
a[3,1] = 6
a[4,0] = 4
a[4,1] = 8

You can test the above example here! ➡ VB.net Online Compiler

Multidimensional Arrays in VB.net

Multidimensional Arrays in VB.net can be used to store multiple dimensions in a tabular format, such as rows and columns.

The multidimensional array in VB.net supports two or three dimensions.

Declaration of Multidimensional Arrays in VB.net

Declaration of two-dimensional array  
Dim twoDimenArray As Integer( , ) = New Integer(3, 2) {}  
Or Dim arr(5, 3) As Integer  
Representation of Three Dimensional array  
Dim arrThree(2, 4, 3) As Integer  
Or Dim arr1 As Integer( , , ) = New Integer(5, 5, 5) { }  

Example Program of Multidimensional Arrays in VB.net:

Imports System  
Module MultidimenArray  
    Sub Main()  
        ' Definition of 2 Dimensional Array  
        Dim intArray(,) As Integer = {{5, 4}, {3, 2}, {4, 7}, {4, 5}}  
  
        ' Definition of 3 Dimensional Array  
        Dim threeDimen(,,) As Integer =  
            {{{1, 3, 2}, {2, 3, 4}},  
            {{5, 3, 6}, {3, 4, 5}},  
        {{1, 2, 2}, {5, 2, 3}}}  
  
        Console.WriteLine(" Two Dimensional Arraye in VB.NET are")  
        For i As Integer = 0 To 3  
            For j As Integer = 0 To 1  
                Console.WriteLine("intArray[{0}, {1}] = {2}", i, j, intArray(i, j))  
            Next j  
        Next i  
  
        Console.WriteLine(" Three Dimensional Arraye in VB.NET are")  
        For i As Integer = 0 To 2 - 1  
            For j As Integer = 0 To 2 - 1  
                For k As Integer = 0 To 4  
                    Console.WriteLine("intArray[{0}, {1}, {2}] = {3}", i, j, k, threeDimen(i, j, k))  
                Next k  
            Next j  
        Next i  
    End Sub  
End Module

When the above code is compiled and executed, it produces the following result:

Two Dimensional Arraye in VB.NET are
intArray[0, 0] = 5
intArray[0, 1] = 4
intArray[1, 0] = 3
intArray[1, 1] = 2
intArray[2, 0] = 4
intArray[2, 1] = 7
intArray[3, 0] = 4
intArray[3, 1] = 5
Three Dimensional Arraye in VB.NET are
intArray[0, 0, 0] = 1
intArray[0, 0, 1] = 3
intArray[0, 0, 2] = 2
intArray[0, 1, 0] = 2
intArray[0, 1, 1] = 3
intArray[0, 1, 2] = 4
intArray[1, 0, 0] = 5
intArray[1, 0, 1] = 3
intArray[1, 0, 2] = 6
intArray[1, 1, 0] = 3
intArray[1, 1, 1] = 4
intArray[1, 1, 2] = 5

You can test the above example here! ➡ VB.net Online Compiler

Array Class in VB.net

The Array class in VB.net is the base class for all the arrays in VB.net. It is defined in the System namespace.

The Array class provides various properties and methods to work with arrays.

Properties of the Array Class

The following table provides some of the most commonly used properties of the Array class.

Methods of the Array Class

The following table provides some of the most commonly used methods of the Array class.

Summary

Arrays in VB.net are used for storing data elements that belong to the same data type. A dynamic array in VB.net allows the user to resize it by adding more elements to it.

You use the command ReDim for adding elements to an existing array The size of a fixed-size array in VB.net cannot be changed.

The array elements are ordered using indexes, with the first element being at index 0 and the last element at index n-1, where n is the total number of array elements.

Arrays can be deleted using the Erase function You can use split and join functions to split or join a string array respectively.

PREVIOUS

Date and Time

NEXT

Collection