Mastering Arrays in VB.Net: The Ultimate Guide with Code Examples

Welcome friend! This comprehensive guide will help you master arrays in Visual Basic.Net from basic declaration all the way to advanced operations.

Arrays allow storing collections of data for fast access and manipulation which is integral for building efficient programs. We will explore various array features through simple examples that you can try out.

So let‘s get started!

What is an Array?

An array is a data structure that stores elements of same data type like integers, strings etc. Elements are stored in contiguous memory locations and accessed using numeric indexes.

For example, to store 5 student marks:

Dim marks(4) As Integer

The integer array marks has index 0 to 4 for storing 5 elements.

Arrays have following advantages:

  • Fast lookup of elements based on index – O(1) time
  • Improved cache performance as data stored together
  • Support common operations like search, sort etc
  • Concise code by just changing index values
  • Flexible declaration without hardcoding values

Let‘s next see how to declare arrays in VB.

Array Declaration in VB

The basic syntax for array declaration is:

Dim arrayName(index1 To index2) As dataType

For example, 

Dim numbers(0 To 9) As Integer

Declares an integer array numbers that can store 10 elements accessed using index 0 to 9.

We can also declare arrays without specifying size:

Dim names() As String

This dynamic array grows in size later using ReDim. More on this coming up.

Initializing Arrays in VB.Net

We can initialize array elements during declaration itself: 

Dim colors() As String = {"Red", "Blue", "Green"}

This directly creates a 3 element string array with values.

For numbers, we don‘t need quotes:

Dim points() As Integer = {2, 6, 7, 5}

Let‘s summarize arrays so far:

  • Arrays contain elements of same data type
  • Elements accessed by numeric index starting from 0
  • Declaration specifies name, size (optional), data type
  • Can initialize elements during array creation

Simple right? Now let‘s tackle resizing arrays!

Resizing Arrays in VB.Net

There are two kinds of arrays in VB:

  1. Fixed size – Size cannot be changed
  2. Dynamic – Can resize to grow or shrink

Fixed Size Arrays

These are declared with specified size:

Dim matrix(2, 3) As Double

This allocates a 2D array with 2 rows and 3 columns.

Total elements = 6, indexed from (0,0) to (2, 3).

Trying to resize above array will ERROR! Fixed arrays suit apps where number of elements are known beforehand.

Dynamic Arrays

These arrays can grow and shrink in size.

Declaration leaves size unspecified: 

Dim names() As String

We use ReDim Preserve to resize:

ReDim Preserve names(8)

This changes size to 9 elements based on new index range 0 to 8.

Key Rules for ReDim:

  1. Old elements RETAINED at same index positions
  2. New elements get default initialization value
  3. Cannot resize fixed size arrays

Being able to resize is useful when working with dynamic data. Let‘s see more examples.

Accessing Array Elements

Array elements are accessed using numeric indexes.

Valid index starts from 0, going up to (total elements – 1).

Let‘s access elements from previous 3 color array example:

Dim colors() As String = {"Red", "Blue", "Green"}  

Console.WriteLine(colors(1)) ‘Prints Blue

Trying to access invalid indexes outside 0-2 range will error.

We can also loop through arrays sequentially:

For i = 0 To colors.Length - 1
  Console.WriteLine(colors(i))
Next

Here .Length property gives us total elements to iterate through, instead of using hard-coded value.

This approach suits dynamic arrays well since we need not worry about size changes.

Adding New Elements in Array

For fixed size arrays, adding elements beyond initial size is NOT possible.

For dynamic arrays, here is how we add new elements:

Step 1: Resize array using ReDim Preserve 

Dim fruits() As String  

ReDim Preserve fruits(1)

Step 2: Assign values for new indexes

fruits(0) = "Apple" 
fruits(1) = "Banana" 

ReDim Preserve fruits(4)
fruits(3) = "Mango"

ReDim grows size from 2 elements to 5 elements.

We assign "Mango" at the new available index. Pretty neat!

Sorting Arrays in VB.Net

Sorting arrays is essential before processing data. VB provides built-in sorting functions.

Ascending Order

Dim numbers() As Integer = {4, 8, 2, 9} 

Array.Sort(numbers)  

For i = 0 To numbers.Length - 1
   Console.WriteLine(numbers(i)) 
Next

‘Prints 2 4 8 9

.Sort() sorts elements of array numbers in ascending sequence.

For descending we call .Reverse():

Array.Reverse(numbers)

‘Prints 9 8 4 2

No need to write our own sort logic! Sorting improves efficiency for algorithms like binary search.

Multidimensional Arrays

So far we‘ve seen single dimensional arrays with one index.

VB also supports multidimensional arrays:

Dim grid(10, 5) As Integer

This is a 2D array with:

  • 10 rows
  • 5 columns
  • Total elements = 10 * 5 = 50

Access elements using two indexes:

grid(2, 3) = 5 ‘ Row 3, Column 4 position

Console.WriteLine(grid(7, 2)) ‘ Prints element at indexes

Multidimensional arrays enable matrix and tabular data representations for computations.

Measuring Array Performance

Let‘s analyze time complexity of key array operations using Big O notation.

Operation Time Complexity
Indexed Read O(1)
Indexed Write O(1)
Insertion O(n)
Deletion O(n)
Search O(n)
Access nth element O(1)
Sorting O(n log n)
  • Indexed read/write is the fastest with constant time. This random access makes arrays very efficient compared to lists or queues.
  • Insertion and deletion in middle positions is costly as it requires shifting subsequent elements.
  • Linear search requires scanning entire array hence scales as per size ‘n‘. Faster algorithms like binary search available on sorted arrays.

Space complexity is O(n) linear to store ‘n‘ elements.

Let‘s now see some real-world examples using arrays…

Use Case 1: Stock Price Data Analysis

Today stock markets generate huge ticks data. Let‘s see how arrays help us store and process this data efficiently.

Step 1) Data Acquisition

Get ticks data using subscription APIs or data feeds in CSV format.

Sample data format:

IBM,04-05-2020 09:15,125.48  
IBM,04-05-2020 09:16,125.82
IBM,04-05-2020 09:18,126.05
AAPL,04-05-2020 09:20,123.43
AMZN,04-05-2020 09:22,105.55

Step 2) Store into arrays

We declare arrays based on metrics we want to analyze or visualize: 

Dim times(1000) As Date
Dim prices(1000) As Double  
Dim symbols(1000) As String

Here I have assumed max 1000 ticks, for multiple stocks over 8 hours. Dynamically resize if more data encountered.

Step 3) Populate arrays

Write a method InsertTick() to extract fields from CSV and populate respective arrays at each index.

Now when we plot prices or calculate 20 day moving average, array access makes computation very fast.

Benefits

  • Code efficiency to calculate metrics like min/max price
  • Easy integration with visualization libraries
  • Fast performance of O(1) access

This example demonstrates how arrays enable writing performant analysis software programs.

Comparing VB.Net Arrays to Other Languages

The basic array concepts in VB.Net are quite similar across mainstream languages like Java, C# etc. However here are some key differences:

  • VB arrays are zero indexed vs one indexed arrays in Lisp and Fortran. All latest languages use zero index.
  • Size is fixed for Java arrays while VB and C# support dynamic arrays changing size at runtime.
  • JavaScript arrays are always dynamic which also permits heterogeneous data types but is less type-safe.
  • Insertion in middle of array causes full shift of elements in VB/C# vs targeted shift in Java by moving only subset of elements.
  • VB.Net also handles multi-dimensional arrays seamlessly whereas other languages use linearized single dimension or third party libraries.
  • Overall, VB strikes good balance between flexibility and control vs raw high performance like C/C++ with more pointer arithmetic.

These semantics differences slightly alter how we write array logic between languages but core working remains same.

Additional Array Operations

Let‘s discuss some more useful array operations and utilities provided in VB.

Custom Sorting

We can define custom sorting logic using Array.Sort() override:

Array.Sort(names, New MyComparer())

Public Class MyComparer
   Implements IComparer(Of String)

   Public Function Compare(x As String, y As String) As Integer
      Return y.CompareTo(x)  
   End Function

End Class

Here MyComparer implements custom descending sort by reversing elements.

Copying

We can copy elements from one array into another using .CopyTo(): 

Dim source = {1, 2, 3}
Dim destination(2) As Integer 

Source.CopyTo(destination, 0)

Check If Sorted

Call .IsSorted() method which returns boolean true if elements arranged in sorted order either ascending or descending.

Binary Search

A faster search for sorted arrays is Array.BinarySearch() with O(log n) time.

Therefore key array capabilities in VB.Net include:

  • Declaration and Initialization
  • Sorting, Copying and Checking if sorted
  • Search Algorithms like Binary Search
  • Dynamic Resizing
  • Customizable Operations

These built-in functions enable creating feature rich applications using arrays!

In Summary

In this comprehensive guide, we explored various facets around using arrays in Visual Basic.Net through simple illustrative examples.

Here are the key takeways:

  • Arrays allow storing collection of elements belonging to same data type
  • Choice between fixed size vs dynamic arrays
  • Indexed access offers O(1) fast reads and writes
  • Built-in support for sorts, searches, multi-dimensional arrays
  • Resizing dynamic arrays using Preserve Redim
  • Split and Join for string array manipulations
  • Custom sort orders possible by supplying comparator

I hope you enjoyed this guide explaining arrays in VB.Net! Feel free to try out the code examples.

Arrays form fundamental data structure for efficiently handling collection data. Go forth and build cool apps using VB arrays!

Read More Topics