Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Una matrice è un set di valori, definiti elementi definiti logicamente correlati l'uno all'altro. Ad esempio, una matrice può essere costituita dal numero di studenti in ogni grado di una scuola di grammatica; ogni elemento della matrice è il numero di studenti in un singolo grado. Analogamente, una matrice può essere costituita dai voti di uno studente per una classe; ogni elemento della matrice è un singolo grado.
È possibile usare singole variabili per archiviare ogni elemento di dati. Ad esempio, se l'applicazione analizza i voti degli studenti, è possibile usare una variabile separata per il grado di ogni studente, ad esempio englishGrade1, e englishGrade2così via. Questo approccio presenta tre limitazioni principali:
- In fase di progettazione, dobbiamo sapere esattamente quante valutazioni dobbiamo gestire.
- La gestione di un numero elevato di voti diventa rapidamente difficile. Questo a sua volta rende un'applicazione molto più probabile di avere bug gravi.
- È difficile da gestire. Ogni nuovo livello aggiunto richiede che l'applicazione venga modificata, ricompilata e ridistribuita.
Usando una matrice, è possibile fare riferimento a questi valori correlati con lo stesso nome e usare un numero denominato indice o pedice per identificare un singolo elemento in base alla relativa posizione nella matrice. Gli indici di un array vanno da 0 fino a uno meno del numero totale di elementi nell'array. Quando si utilizza la sintassi di Visual Basic per definire le dimensioni di una matrice, si specifica il relativo indice più alto, non il numero totale di elementi nella matrice. È possibile trattare l'array come un'unità e la possibilità di iterare sui suoi elementi ti libera dalla necessità di sapere esattamente quanti elementi contiene in fase di progettazione.
Alcuni esempi rapidi prima della spiegazione:
' 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(,) {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}
' Declare a jagged array
Dim sales()() As Double = New Double(11)() {}
Elementi della matrice in una matrice semplice
Creiamo una matrice denominata students per archiviare il numero di studenti in ogni classe in una scuola elementare. Gli indici degli elementi sono compresi tra 0 e 6. L'uso di questa matrice è più semplice rispetto alla dichiarazione di sette variabili.
La figura seguente mostra la students matrice. Per ogni elemento della matrice:
L'indice dell'elemento rappresenta il grado (indice 0 rappresenta l'asilo).
Il valore contenuto nell'elemento rappresenta il numero di studenti in tale grado.
L'esempio seguente contiene il codice di Visual Basic che crea e usa la matrice:
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
L'esempio esegue tre operazioni:
- Dichiara una
studentsmatrice con sette elementi. Il numero6nella dichiarazione di matrice indica l'ultimo indice nella matrice, ovvero uno minore del numero di elementi nella matrice. - Assegna valori a ogni elemento della matrice. L'accesso agli elementi della matrice viene eseguito usando il nome della matrice e includendo l'indice del singolo elemento tra parentesi.
- Elenca ogni valore della matrice. Nell'esempio viene utilizzata un'istruzione
Forper accedere a ogni elemento della matrice in base al relativo numero di indice.
La students matrice nell'esempio precedente è una matrice unidimensionale perché usa un indice. Una matrice che usa più indici o pedice è denominata multidimensionale. Per altre informazioni, vedere il resto di questo articolo e Dimensioni di Matrice in Visual Basic.
Creazione di una matrice
È possibile definire le dimensioni di una matrice in diversi modi:
È possibile specificare le dimensioni quando la matrice viene dichiarata:
' 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È possibile usare una
Newclausola per specificare le dimensioni di una matrice al momento della creazione:' 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)() {}
Se si dispone di una matrice esistente, è possibile ridefinirne le dimensioni usando l'istruzione ReDim . È possibile specificare che l'istruzione ReDim mantiene i valori presenti nella matrice oppure che crea una matrice vuota. Nell'esempio seguente vengono illustrati diversi usi dell'istruzione ReDim per modificare le dimensioni di una matrice esistente.
' 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)
Per altre informazioni, vedere l'istruzione ReDim.
Archiviazione di valori in una matrice
È possibile accedere a ogni posizione in una matrice usando un indice di tipo Integer. È possibile archiviare e recuperare valori in una matrice facendo riferimento a ogni posizione della matrice usando il relativo indice racchiuso tra parentesi. Gli indici per le matrici multidimensionali sono separati da virgole (,). È necessario un indice per ogni dimensione della matrice.
Nell'esempio seguente vengono illustrate alcune istruzioni che archiviano e recuperano valori in matrici.
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
Popolamento di una matrice con valori letterali di matrice
Usando un valore letterale di matrice, è possibile popolare una matrice con un set iniziale di valori contemporaneamente creato. Un letterale di matrice è costituito da una lista di valori separati da virgole racchiusi tra parentesi graffe ({}).
Quando si crea un array usando un letterale di array, è possibile specificare il tipo di array o utilizzare l'inferenza del tipo per determinarlo. L'esempio seguente mostra entrambe le opzioni.
' 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 }
Quando si usa l'inferenza del tipo, il tipo della matrice viene determinato dal tipo dominante nell'elenco di valori letterali. Il tipo dominante è il tipo a cui tutti gli altri tipi della matrice possono essere ampliati. Se questo tipo univoco non può essere determinato, il tipo dominante è il tipo univoco a cui tutti gli altri tipi della matrice possono restringere. Se nessuno di questi tipi univoci può essere determinato, il tipo dominante è Object. Ad esempio, se l'elenco di valori forniti al valore letterale della matrice contiene valori di tipo Integer, Longe Double, la matrice risultante è di tipo Double. Poiché Integer e Long si estende solo a Double, Double è il tipo dominante. Per altre informazioni, vedere Conversioni di tipo Widening and Narrowing.
Annotazioni
È possibile usare l'inferenza del tipo solo per le matrici definite come variabili locali in un membro di tipo. Se una definizione di tipo esplicito è assente, le matrici definite con valori letterali di matrice a livello di classe sono di tipo Object[]. Per altre informazioni, vedere Inferenza del tipo locale.
Si noti che l'esempio precedente definisce values come matrice di tipo Double anche se tutti i valori letterali della matrice sono di tipo Integer. È possibile creare questa matrice perché i valori nel valore letterale della matrice possono essere ampliati ai Double valori.
È anche possibile creare e popolare una matrice multidimensionale usando valori letterali di matrice annidati. I valori letterali di matrice annidati devono avere una serie di dimensioni coerenti con la matrice risultante. Nell'esempio seguente viene creato un array bidimensionale di numeri interi usando array letterali annidati.
' 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}}
Quando si usano valori letterali di matrice annidati per creare e popolare una matrice, si verifica un errore se il numero di elementi nei valori letterali di matrice annidati non corrisponde. Si verifica anche un errore se si dichiara in modo esplicito la variabile di matrice in modo che abbia un numero di dimensioni diverso rispetto ai valori letterali della matrice.
Proprio come per le matrici unidimensionali, è possibile basarsi sull'inferenza dei tipi durante la creazione di una matrice multidimensionale con valori letterali di matrice annidati. Il tipo dedotto è il tipo dominante per tutti i valori in tutti i letterali di array per tutti i livelli di annidamento. Nell'esempio seguente viene creata una matrice bidimensionale di tipo Double[,] da valori di tipo Integer e Double.
Dim arr = {{1, 2.0}, {3, 4}, {5, 6}, {7, 8}}
Per altri esempi, vedere Procedura: Inizializzare una variabile di matrice in Visual Basic.
Iterazione attraverso una matrice
Quando si scorre una matrice, si accede a ogni elemento della matrice dall'indice più basso al più alto o dal più alto al più basso. In genere, usare l'istruzione For...Next o l'istruzione For Each...Next per scorrere gli elementi di una matrice. Quando non si conoscono i limiti superiori della matrice, è possibile chiamare il Array.GetUpperBound metodo per ottenere il valore più alto dell'indice. Anche se il valore di indice più basso è quasi sempre 0, è possibile chiamare il Array.GetLowerBound metodo per ottenere il valore più basso dell'indice.
Nell'esempio seguente viene eseguita un'iterazione di una matrice unidimensionale usando l'istruzione For...Next .
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
L'esempio seguente scorre una matrice multidimensionale usando un'istruzione For...Next . Il GetUpperBound metodo ha un parametro che specifica la dimensione.
GetUpperBound(0) restituisce l'indice più alto della prima dimensione e GetUpperBound(1) restituisce l'indice più alto della seconda dimensione.
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
L'esempio seguente usa un'istruzione For Each... Next per iterare una matrice unidimensionale e una matrice bidimensionale.
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
Dimensione dell'array
La dimensione di una matrice è il prodotto delle lunghezze di tutte le relative dimensioni. Rappresenta il numero totale di elementi attualmente contenuti nella matrice. Nell'esempio seguente, ad esempio, viene dichiarata una matrice bidimensionale con quattro elementi in ogni dimensione. Come illustrato nell'output dell'esempio, la dimensione della matrice è 16 (o (3 + 1) * (3 + 1).
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
Annotazioni
Questa discussione sulle dimensioni della matrice non si applica alle matrici irregolari. Per informazioni sulle matrici irregolari e sulla determinazione delle dimensioni di una matrice frastagliata, vedere la sezione Matrici frastagliati .
È possibile trovare le dimensioni di una matrice usando la Array.Length proprietà . È possibile trovare la lunghezza di ogni dimensione di una matrice multidimensionale usando il Array.GetLength metodo .
È possibile ridimensionare una variabile di matrice assegnando un nuovo oggetto matrice o usando l'istruzione ReDim . Nell'esempio seguente viene utilizzata l'istruzione ReDim per modificare una matrice di 100 elementi in una matrice di 51 elementi.
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
Quando si gestiscono le dimensioni di una matrice, è necessario tenere presenti diversi aspetti.
| Note | |
|---|---|
| Dimensione della lunghezza | L'indice di ogni dimensione è basato su 0, ovvero è compreso tra 0 e il limite superiore. Pertanto, la lunghezza di una determinata dimensione è maggiore del limite superiore dichiarato di tale dimensione. |
| Limiti di lunghezza | La lunghezza di ogni dimensione di una matrice è limitata al valore massimo del Integer tipo di dati, ovvero Int32.MaxValue o (2 ^ 31) - 1. Tuttavia, la dimensione totale di una matrice è limitata anche dalla memoria disponibile nel sistema. Se si tenta di inizializzare una matrice che supera la quantità di memoria disponibile, il runtime genera un'eccezione OutOfMemoryException. |
| Dimensioni e dimensioni degli elementi | Le dimensioni di una matrice sono indipendenti dal tipo di dati dei relativi elementi. La dimensione rappresenta sempre il numero totale di elementi, non il numero di byte utilizzati in memoria. |
| Consumo di memoria | Non è sicuro fare ipotesi relative al modo in cui una matrice viene archiviata in memoria. L'archiviazione varia in base alle piattaforme di larghezze dei dati diverse, quindi la stessa matrice può utilizzare più memoria in un sistema a 64 bit rispetto a un sistema a 32 bit. A seconda della configurazione di sistema quando si inizializza una matrice, Common Language Runtime (CLR) può assegnare lo spazio di archiviazione agli elementi di tipo pack il più vicino possibile o allinearli tutti sui limiti hardware naturali. Inoltre, una matrice richiede un sovraccarico di archiviazione per le informazioni sul controllo e questo sovraccarico aumenta con ogni dimensione aggiunta. |
Tipo di matrice
Ogni matrice ha un tipo di dati, che differisce dal tipo di dati dei relativi elementi. Nessun tipo di dati singolo per tutte le matrici. Al contrario, il tipo di dati di una matrice è determinato dal numero di dimensioni, o rango, della matrice e dal tipo di dati degli elementi nella matrice. Due variabili di matrice sono dello stesso tipo di dati solo quando hanno lo stesso rango e i relativi elementi hanno lo stesso tipo di dati. Le lunghezze delle dimensioni di una matrice non influiscono sul tipo di dati della matrice.
Ogni matrice eredita dalla System.Array classe ed è possibile dichiarare una variabile di tipo Array, ma non è possibile creare una matrice di tipo Array. Ad esempio, anche se il codice seguente dichiara la arr variabile di tipo Array e chiama il Array.CreateInstance metodo per creare un'istanza della matrice, il tipo della matrice dimostra di essere Object[].
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[]
Inoltre, l'istruzione ReDim non può operare su una variabile dichiarata come tipo Array. Per questi motivi, e per la sicurezza dei tipi, è consigliabile dichiarare ogni matrice come tipo specifico.
È possibile trovare il tipo di dati di una matrice o dei relativi elementi in diversi modi.
- È possibile chiamare il GetType metodo sulla variabile per ottenere un Type oggetto che rappresenta il tipo di runtime della variabile. L'oggetto Type contiene informazioni complete nelle relative proprietà e metodi.
- È possibile passare la variabile alla funzione TypeName per ottenere un
Stringcon il nome del tipo di runtime.
Nell'esempio seguente viene chiamato il GetType metodo e la TypeName funzione per determinare il tipo di una matrice. Il tipo di matrice è Byte(,). Si noti che la Type.BaseType proprietà indica anche che il tipo di base della matrice di byte è la Array classe .
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(,)
Matrici sia come valori restituiti sia come parametri
Per restituire una matrice da una Function routine, specificare il tipo di dati della matrice e il numero di dimensioni come tipo restituito dell'istruzione Function. All'interno della funzione dichiarare una variabile di matrice locale con lo stesso tipo di dati e il numero di dimensioni.
Nell'istruzione Return includere la variabile di matrice locale senza parentesi.
Per specificare una matrice come parametro di una Sub routine o Function , definire il parametro come matrice con un tipo di dati e un numero di dimensioni specificati. Nella chiamata alla routine passare una variabile di matrice con lo stesso tipo di dati e il numero di dimensioni.
Nell'esempio seguente la GetNumbers funzione restituisce , Integer()una matrice unidimensionale di tipo Integer. La ShowNumbers routine accetta un Integer() argomento.
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
Nell'esempio seguente la GetNumbersMultiDim funzione restituisce , Integer(,)una matrice bidimensionale di tipo Integer. La ShowNumbersMultiDim routine accetta un Integer(,) argomento.
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
Matrici frastagliate
A volte la struttura dei dati nell'applicazione è bidimensionale ma non rettangolare. Ad esempio, è possibile usare una matrice per archiviare i dati relativi alla temperatura elevata di ogni giorno del mese. La prima dimensione della matrice rappresenta il mese, ma la seconda dimensione rappresenta il numero di giorni e il numero di giorni in un mese non è uniforme. Una matrice frastagliata, detta anche matrice di matrici, è progettata per tali scenari. Una matrice frastagliata è una matrice i cui elementi sono anche matrici. Una matrice frastagliata e ogni elemento in una matrice frastagliata può avere una o più dimensioni.
Nell'esempio seguente viene usata una matrice di mesi, ogni elemento di cui è una matrice di giorni. Nell'esempio viene usata una matrice frastagliata perché diversi mesi hanno diversi numeri di giorni. Nell'esempio viene illustrato come creare una matrice frastagliata, assegnarvi valori e recuperarne e visualizzarne i valori.
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
' 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 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
L'esempio precedente assegna valori alla matrice frastagliata usando un ciclo For...Next per elemento. È anche possibile assegnare valori agli elementi di una matrice frastagliata usando valori letterali di matrice annidati. Tuttavia, il tentativo di usare letterali di array annidati, ad esempio, Dim valuesjagged = {{1, 2}, {2, 3, 4}}, genera l'errore del compilatore BC30568. Per correggere l'errore, racchiudere i valori letterali della matrice interna tra parentesi. Le parentesi forzano la valutazione dell'espressione letterale della matrice e i valori risultanti vengono usati con il valore letterale della matrice esterna, come illustrato nell'esempio seguente.
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
Una matrice frastagliata è una matrice unidimensionale i cui elementi contengono matrici. Di conseguenza, la proprietà Array.Length e il metodo Array.GetLength(0) restituiscono il numero di elementi nella matrice unidimensionale, mentre Array.GetLength(1) genera un'eccezione di tipo IndexOutOfRangeException perché una matrice irregolare non è multidimensionale. È possibile determinare il numero di elementi in ogni sottomaschera recuperando il valore della proprietà di Array.Length ogni sottomaschera. Nell'esempio seguente viene illustrato come determinare il numero di elementi in una matrice frastagliata.
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
Matrici di lunghezza zero
Visual Basic distingue una matrice non inizializzata (una matrice il cui valore è Nothing) e una matrice di lunghezza zero o una matrice vuota (una matrice senza elementi). Una matrice non inizializzata è una matrice che non è stata ridimensionata o a cui è stato assegnato alcun valore. Per esempio:
Dim arr() As String
Una matrice di lunghezza zero viene dichiarata con una dimensione pari a -1. Per esempio:
Dim arrZ(-1) As String
Potrebbe essere necessario creare una matrice di lunghezza zero nelle circostanze seguenti:
Senza rischiare un'eccezioneNullReferenceException, il codice deve accedere ai membri della classe Array, come Length o Rank, o chiamare una funzione di Visual Basic come UBound.
Si vuole mantenere il codice semplice senza dover considerare
Nothingcome un caso speciale.Il codice interagisce con un'API (Application Programming Interface) che richiede di passare una matrice di lunghezza zero a una o più routine o restituisce una matrice di lunghezza zero da una o più procedure.
Suddivisione di una matrice
In alcuni casi, potrebbe essere necessario suddividere una singola matrice in più matrici. Ciò implica l'identificazione del punto o dei punti in cui deve essere divisa la matrice e quindi di dividere la matrice in due o più matrici separate.
Annotazioni
Questa sezione non illustra la suddivisione di una singola stringa in una matrice di stringhe basata su alcuni delimitatori. Per informazioni sulla suddivisione di una stringa, vedere il String.Split metodo .
I criteri più comuni per la divisione di una matrice sono:
Numero di elementi nella matrice. Ad esempio, è possibile suddividere una matrice di più di un numero specificato di elementi in un numero di parti approssimativamente uguali. A questo scopo, è possibile usare il valore restituito dal Array.Length metodo o Array.GetLength .
Valore di un elemento, che funge da delimitatore che indica dove deve essere divisa la matrice. È possibile cercare un valore specifico chiamando i Array.FindIndex metodi e Array.FindLastIndex .
Dopo aver determinato l'indice o gli indici in corrispondenza del quale deve essere divisa la matrice, è possibile creare le singole matrici chiamando il Array.Copy metodo .
L'esempio seguente suddivide una matrice in due matrici di dimensioni approssimativamente uguali. Se il numero totale di elementi della matrice è dispari, la prima matrice ha un altro elemento rispetto al secondo.
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, 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
L'esempio seguente suddivide una matrice di stringhe in due matrici in base alla presenza di un elemento il cui valore è "zzz", che funge da delimitatore di matrice. Le nuove matrici non includono l'elemento che contiene il delimitatore.
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
End Module
Unione di matrici
È anche possibile combinare un numero di matrici in una singola matrice più grande. A tale scopo, si usa anche il Array.Copy metodo .
Annotazioni
Questa sezione non illustra l'unione di una matrice di stringhe in una singola stringa. Per informazioni sull'unione di una matrice di stringhe, vedere il String.Join metodo .
Prima di copiare gli elementi di ogni matrice nella nuova matrice, è necessario assicurarsi di aver inizializzato la matrice in modo che sia sufficientemente grande da contenere la nuova matrice. È possibile eseguire questa operazione in uno dei due modi seguenti:
- Usare l'istruzione
ReDim Preserveper espandere dinamicamente la matrice prima di aggiungere nuovi elementi. Questa è la tecnica più semplice, ma può comportare una riduzione delle prestazioni e un consumo eccessivo di memoria quando si copiano matrici di grandi dimensioni. - Calcolare il numero totale di elementi necessari per la nuova matrice di grandi dimensioni, quindi aggiungervi gli elementi di ogni matrice di origine.
Nell'esempio seguente viene usato il secondo approccio per aggiungere quattro matrici con dieci elementi ciascuno a una singola matrice.
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
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.
Poiché in questo caso le matrici di origine sono tutte di piccole dimensioni, è anche possibile espandere dinamicamente la matrice man mano che si aggiungono gli elementi di ogni nuova matrice. L'esempio seguente esegue questa operazione.
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 = {}
' 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.
Raccolte come alternativa alle matrici
Le matrici sono più utili per la creazione e l'uso di un numero fisso di oggetti fortemente tipizzati. Le raccolte offrono un modo più flessibile per lavorare con gruppi di oggetti. A differenza delle matrici, che richiedono di modificare in modo esplicito le dimensioni di una matrice con l'istruzioneReDim, le raccolte aumentano e si riducono in modo dinamico in base alle esigenze di un'applicazione.
Quando si usa ReDim per ridimensionare una matrice, Visual Basic crea una nuova matrice e rilascia quella precedente. Questo richiede tempo di esecuzione. Pertanto, se il numero di elementi su cui stai lavorando cambia frequentemente, o non puoi prevedere il numero massimo di elementi necessari, in genere si otterranno prestazioni migliori usando una raccolta.
Per alcune raccolte, è possibile assegnare una chiave a qualsiasi oggetto inserito nella raccolta in modo da poter recuperare rapidamente l'oggetto usando la chiave .
Se la raccolta contiene elementi di un solo tipo di dati, è possibile usare una delle classi dello spazio dei nomi System.Collections.Generic. Una raccolta generica applica la sicurezza dei tipi in modo che nessun altro tipo di dati possa essere aggiunto.
Per altre informazioni sulle raccolte, vedere Raccolte.
Argomenti correlati
| Termine | Definizione |
|---|---|
| Dimensioni della matrice in Visual Basic | Illustra la classificazione e le dimensioni nelle matrici. |
| Procedura: Inizializzare una variabile di matrice in Visual Basic | Si descrive come popolare le matrici con valori iniziali. |
| Procedura: Ordinare una matrice in Visual Basic | Illustra come ordinare gli elementi di una matrice in ordine alfabetico. |
| Procedura: Assegnare una matrice a un'altra matrice | Descrive le regole e i passaggi per l'assegnazione di una matrice a un'altra variabile di matrice. |
| Risoluzione dei problemi relativi alle matrici | Vengono illustrati alcuni problemi comuni che si verificano quando si lavora con le matrici. |
Vedere anche
Collabora con noi su GitHub
L'origine di questo contenuto è disponibile in GitHub, in cui è anche possibile creare ed esaminare i problemi e le richieste pull. Per ulteriori informazioni, vedere la guida per i collaboratori.
