Tömbök a Visual Basicben

A tömb olyan értékek halmaza, amelyek logikailag kapcsolódnak egymáshoz. Egy tömb például a gimnáziumok egyes osztályaiban lévő tanulók számából állhat; a tömb minden eleme az egy osztályban lévő tanulók száma. Hasonlóképpen, a tömbök egy osztály tanulói osztályzataiból is állhatnak; a tömb minden eleme egyetlen osztályzat.

Az egyes változók használatával minden egyes adatelemet tárolhat. Ha például az alkalmazás elemzi a tanulók osztályzatait, használhatunk egy külön változót az egyes tanulók osztályzataihoz, például englishGrade1, englishGrade2stb. Ez a megközelítés három fő korlátozást jelent:

• A tervezéskor pontosan tudni kell, hogy hány osztályzatot kell kezelnünk.
• A nagy mennyiségű osztályzat gyors kezelése hamar nehézkessé válik. Ez viszont sokkal valószínűbbé teszi, hogy egy alkalmazásnak súlyos hibái vannak.
• Nehéz fenntartani. Minden újonnan hozzáadott osztályhoz módosítani, újrafordíteni és újra üzembe helyezni kell az alkalmazást.

Egy tömb használatával ugyanezzel a névvel hivatkozhat ezekre a kapcsolódó értékekre, és egy indexnek vagy alsó indexnek nevezett számmal azonosíthat egy adott elemet a tömbben elfoglalt helye alapján. A tömb indexei 0-tól a tömb elemeinek számánál eggyel kisebb értékig terjednek. Ha a Visual Basic szintaxist használja a tömb méretének meghatározásához, akkor a legmagasabb indexet kell megadnia, nem pedig a tömb elemeinek teljes számát. A tömböt egységként kezelheti, és az elemek iterálásának lehetősége szükségtelenné teszi, hogy pontosan tudja, hány elemet tartalmaz a tervezéskor.

Néhány gyors példa a magyarázat előtt:

' 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)() {}

Tömbelemek egy egyszerű tömbben

Hozzunk létre egy tömböt students , amely egy gimnáziumban tárolja az egyes osztályok tanulóinak számát. Az elemek indexei 0 és 6 között mozognak. A tömb használata egyszerűbb, mint hét változó deklarálása.

Az alábbi ábrán a students tömb látható. A tömb minden eleméhez:

• Az elem indexe az osztályzatot jelöli (a 0. index az óvodát jelöli).

• Az elemben található érték az adott osztályzat tanulóinak számát jelöli.

Az alábbi példa a tömböt létrehozó és használó Visual Basic-kódot tartalmazza:

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

A példa három dolgot tesz:

• Hét elemet tartalmazó tömböt deklarál students . A tömbdeklarációban szereplő szám 6 a tömb utolsó indexét jelzi; eggyel kevesebb, mint a tömb elemeinek száma.
• Értékeket rendel a tömb minden eleméhez. A tömbelemek a tömb nevével és az egyes elemek zárójelben lévő indexével érhetők el.
• Felsorolja a tömb minden értékét. A példa egy utasítással For éri el a tömb egyes elemeit az indexszám alapján.

Az students előző példában szereplő tömb egy egydimenziós tömb, mert egy indexet használ. Egynél több indexet vagy alsó indexet használó tömböt többdimenziósnak nevezünk. További információkért tekintse meg a cikk további részeit és a Visual Basic tömbdimenzióit.

Tömb létrehozása

A tömb méretét többféleképpen is meghatározhatja:

• A tömb deklarálásakor megadhatja a méretet:

  ' 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
  

• Használhat egy New záradékot arra, hogy megadja egy tömb méretét, amikor létrejön:

  ' 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)() {}
  

Ha már rendelkezik tömbbel, az utasítással újradefinitálhatja a ReDim méretét. Megadhatja, hogy az ReDim utasítás megtartsa a tömbben lévő értékeket, vagy megadhatja, hogy üres tömböt hoz létre. Az alábbi példa az ReDim utasítás különböző használatát mutatja be egy meglévő tömb méretének módosításához.

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

További információkért lásd a ReDim utasítást.

Értékek tárolása tömbben

Egy tömb minden helyét egy típusindex Integerhasználatával érheti el. Az értékeket egy tömbben tárolhatja és lekérheti, ha az egyes tömbhelyekre hivatkozik a zárójelben található index használatával. A többdimenziós tömbök indexei vesszővel (,) vannak elválasztva. Minden tömbdimenzióhoz egy indexre van szükség.

Az alábbi példa néhány olyan utasítást mutat be, amelyek tömbökben tárolnak és kérnek le értékeket.

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

Tömb feltöltése tömb literálokkal

Tömbkonstans használatával egy tömböt feltölthet kezdeti értékekkel a létrehozáskor. A tömbkonstans egy kapcsos zárójelek közé zárt lista, amely vesszővel elválasztott értékekből áll{}.

Ha tömbkonstans használatával hoz létre tömböt, megadhatja a tömbtípust, vagy típuskövetkeztetést használhat a tömb típusának meghatározásához. Az alábbi példában mindkét lehetőség látható.

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

Típuskövetkeztetés használatakor a tömb típusát a konstans értékek listájában szereplő domináns típus határozza meg. A domináns típus az a típus, amelyre a tömb összes többi típusa szélesedhet. Ha ez az egyedi típus nem határozható meg, a domináns típus az az egyedi típus, amelyre a tömb többi típusa szűkíthető. Ha ezek közül az egyedi típusok közül egyik sem határozható meg, a domináns típus a Object. Például, ha a tömbkonstanshoz megadott értékek listája Integer, Long, és Double típusú értékeket tartalmaz, az így kapott tömb típusa Double. Mivel Integer és Long csak Double-re szélesednek, Double a domináns típus. További információkért lásd a konverziók kibővítését és szűkítését ismertető témakört.

Megjegyzés:

Típuskövetkeztetést csak olyan tömbökhöz használhat, amelyek helyi változóként vannak definiálva egy típustagban. Ha hiányzik egy explicit típusdefiníció, akkor az osztályszinten tömbkonstansokkal definiált tömbök típusa Object[]. További információ: Helyi típus következtetése.

Vegye figyelembe, hogy az előző példa values-t úgy határozza meg, mint egy tömb a(z) Double típusú elemekkel, annak ellenére, hogy az összes tömb literál Integer típusú. Azért hozhatja létre ezt a tömböt, mert a tömbkonstansban szereplő értékek kibővíthetők Double értékekre.

Többdimenziós tömböt is létrehozhat és feltölthet beágyazott tömbkonstansok használatával. A beágyazott tömbkonstansoknak több dimenzióval kell rendelkezniük, amelyek összhangban vannak az eredményként kapott tömbdel. Az alábbi példa egy egész számokból álló kétdimenziós tömböt hoz létre beágyazott tömbkonstansok használatával.

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

Ha beágyazott tömbkonstansokat használ egy tömb létrehozásához és feltöltéséhez, hiba történik, ha a beágyazott tömbkonstansok elemeinek száma nem egyezik meg. Hiba akkor is előfordul, ha explicit módon deklarálja a tömbváltozót, hogy a tömbkonstanstól eltérő számú dimenzióval rendelkezzen.

Az egydimenziós tömbökhöz hasonlóan típuskövetkeztetésre is támaszkodhat, amikor többdimenziós tömböt hoz létre beágyazott tömbkonstansokkal. A következtetett típus az összes tömbkonstans összes értékének domináns típusa az összes beágyazási szinten. Az alábbi példa egy kétdimenziós tömböt hoz létre az Double[,] típusból, a Integer típusból és a Double típusból származó értékekkel.

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

További példákért lásd : Tömbváltozó inicializálása a Visual Basicben.

Iterálás tömbön keresztül

Ha végigfut egy tömbön, a tömb minden eleméhez hozzáfér a legalacsonyabb indextől a legmagasabbig vagy a legmagasabbtól a legalacsonyabbig. Általában használja a For...Következő utasítást vagy a Mindegyik...Következő utasítást, hogy végigiteráljon egy tömb elemein. Ha nem ismeri a tömb felső határait, meghívhatja a Array.GetUpperBound metódust az index legmagasabb értékének lekéréséhez. Bár a legalacsonyabb indexérték majdnem mindig 0, meghívhatja a Array.GetLowerBound metódust az index legalacsonyabb értékének lekéréséhez.

Az alábbi példa egydimenziós tömbön halad végig az For...Next utasítás használatával.

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

Az alábbi példa egy többdimenziós tömbön halad végig egy For...Next utasítás használatával. A GetUpperBound metódus egy paraméterrel rendelkezik, amely meghatározza a dimenziót. GetUpperBound(0) az első dimenzió legmagasabb indexét adja vissza, és GetUpperBound(1) a második dimenzió legmagasabb indexét adja vissza.

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

Az alábbi példa egy For Each...Next utasítást használ egy egydimenziós tömb és egy kétdimenziós tömb bejárására.

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

Tömb mérete

A tömb mérete az összes dimenzió hosszának szorzata. Ez a tömbben jelenleg található elemek teljes számát jelöli. Az alábbi példa például egy kétdimenziós tömböt deklarál, amelyben minden dimenzióban négy elem található. Ahogy a példa kimenete mutatja, a tömb mérete 16 (vagy (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

Megjegyzés:

Ez a tömbméret-vita nem vonatkozik a szaggatott tömbökre. A szaggatott tömbökről és a szaggatott tömbök méretének meghatározásáról a Szaggatott tömbök szakasz nyújt tájékoztatást.

A tömb méretét a Array.Length tulajdonság használatával találhatja meg. A módszer használatával megtalálhatja a többdimenziós tömbök minden dimenziójának hosszát Array.GetLength .

A tömbváltozó átméretezéséhez rendeljen hozzá egy új tömbobjektumot, vagy használja az utasítást ReDim . Az alábbi példa a ReDim utasítást használva átalakít egy 100 elemből álló tömböt 51 elemből állóvá.

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

 

A tömb méretének kezelésekor több dolgot is szem előtt kell tartani.

	Jegyzetek
Dimenzió hossza	Az egyes dimenziók indexe 0-alapú, ami azt jelenti, hogy 0-tól a felső határig terjed. Ezért egy adott dimenzió hossza egy nagyobb, mint az adott dimenzió deklarált felső határa.
Hosszkorlátok	Egy tömb minden dimenziójának hossza az adattípus maximális értékére Integer korlátozódik, amely Int32.MaxValue vagy (2 ^ 31) – 1. A tömbök teljes méretét azonban a rendszeren rendelkezésre álló memória is korlátozza. Ha olyan tömböt próbál inicializálni, amely meghaladja a rendelkezésre álló memória mennyiségét, a futtatási környezet kivételt dob: OutOfMemoryException.
Méret és elemméret	A tömb mérete független az elemek adattípusától. A méret mindig az elemek teljes számát jelöli, nem pedig a memóriában felhasznált bájtok számát.
Memóriahasználat	A tömbök memóriában való tárolására vonatkozó feltételezések nem biztonságosak. A tárolás különböző adatszélességű platformokon változik, így ugyanaz a tömb több memóriát képes felhasználni egy 64 bites rendszeren, mint egy 32 bites rendszeren. A tömb inicializálásakor a rendszerkonfigurációtól függően a közös nyelvi futtatókörnyezet (CLR) a lehető legközelebb tudja hozzárendelni a tárolót az elemek csomagolásához, vagy a természetes hardverhatárokhoz igazíthatja őket. A tömböknek emellett tárolási többletterhelésre van szükség a vezérlési információkhoz, és ez a többletterhelés az egyes hozzáadott dimenziókkal együtt nő.

A tömb típusa

Minden tömb rendelkezik adattípussal, amely eltér az elemek adattípusától. Az összes tömbhöz nincs egyetlen adattípus. Ehelyett a tömb adattípusát a tömb dimenzióinak vagy rangjának száma, valamint a tömb elemeinek adattípusa határozza meg. Két tömbváltozó csak akkor azonos adattípusú, ha azonos a rangjuk, és az elemeik azonos adattípussal rendelkeznek. A tömb méreteinek hossza nem befolyásolja a tömb adattípusát.

Minden tömb öröklődik az System.Array osztálytól, és deklarálhat egy változót típusnak Array, de nem hozhat létre típustömböt Array. Például, habár a következő kódban a arr változó úgy van deklarálva, hogy annak típusa Array, a tömb Array.CreateInstance metódussal történő példányosítása ellenére a tömb tényleges típusa Object[] lesz.

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

A ReDim utasítás sem használható olyan változón, amely típusként lett deklarálva Array. Ezen okokból és a típusbiztonság érdekében célszerű minden tömböt egy adott típusként deklarálni.

Egy tömb vagy annak elemei adattípusát többféleképpen is megismerheti.

• A változó metódusát GetType meghívva lekérheti Type a változó futásidejű típusát képviselő objektumot. Az Type objektum számos információt tartalmaz a tulajdonságairól és módszereiről.
• A változót átadhatja a TypeName függvénynek, hogy lekérje String a futásidejű típus nevét.

Az alábbi példa meghívja a GetType metódust és a TypeName függvényt is a tömb típusának meghatározásához. A tömb típusa Byte(,). Vegye figyelembe, hogy a Type.BaseType tulajdonság azt is jelzi, hogy a bájttömb alaptípusa az Array osztály.

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(,)

Tömbök visszaadott értékekként és paraméterekként

Ha egy tömböt egy Function eljárásból szeretne visszaadni, adja meg a tömb adattípusát és a dimenziók számát a függvényutasítás visszatérési típusaként. A függvényen belül deklaráljon egy helyi tömbváltozót ugyanazzal az adattípussal és dimenziószámmal. A Visszatérési utasításban zárójelek nélkül adja meg a helyi tömbváltozót.

Ha paraméterként szeretne megadni egy tömböt egy Sub eljáráshoz vagy Function eljáráshoz, adja meg a paramétert tömbként egy megadott adattípussal és dimenziószámmal. Az eljárás meghívása során adjon át egy tömbváltozót ugyanazzal az adattípussal és dimenziószámmal.

Az alábbi példában a GetNumbers függvény egy Integer()egydimenziós tömböt Integerad vissza. Az ShowNumbers eljárás argumentumot Integer() fogad el.

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
    

Az alábbi példában a GetNumbersMultiDim függvény egy Integer(,)kétdimenziós tömböt Integerad vissza. Az ShowNumbersMultiDim eljárás argumentumot Integer(,) fogad el.

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

Szaggatott tömbök

Az alkalmazás adatstruktúrája néha kétdimenziós, de nem téglalap alakú. Használhat például egy tömböt a hónap minden napjának magas hőmérsékletére vonatkozó adatok tárolására. A tömb első dimenziója a hónapot jelöli, a második dimenzió viszont a napok számát, a hónap napjainak száma pedig nem egységes. A szaggatott tömböt, amelyet tömbök tömbjének is neveznek, ilyen helyzetekre tervezték. A szaggatott tömb olyan tömb, amelynek elemei szintén tömbök. A szaggatott tömbök és a szaggatott tömb minden eleme egy vagy több dimenzióval rendelkezhet.

Az alábbi példa egy hónapokból álló tömböt használ, amelynek minden eleme egy napi tömb. A példa egy szaggatott tömböt használ, mert a különböző hónapok különböző számú nappal rendelkeznek. A példa bemutatja, hogyan hozhat létre szaggatott tömböt, rendelhet hozzá értékeket, és hogyan kérdezheti le és jelenítheti meg az értékeit.

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

Az előző példa elemenkénti alapon rendel értékeket a szaggatott tömbhöz egy For...Next hurok használatával. Beágyazott tömbkonstansok használatával értékeket is hozzárendelhet a szaggatott tömb elemeihez. A beágyazott tömbkonstansok (például Dim valuesjagged = {{1, 2}, {2, 3, 4}}) használatára tett kísérlet azonban fordítási hibát okoz BC30568. A hiba kijavításához zárójelbe kell tenni a belső tömbkonstansokat. A zárójelek a tömbkonstans kifejezés kiértékelését kényszerítik, az eredményként kapott értékeket pedig a külső tömbkonstanssal használja a rendszer, ahogyan az az alábbi példában látható.

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

A szaggatott tömb egy egydimenziós tömb, amelynek elemei tömböket tartalmaznak. Ezért a Array.Length tulajdonság és a Array.GetLength(0) metódus az egydimenziós tömb elemeinek számát adja vissza, és Array.GetLength(1) egy IndexOutOfRangeException olyan értéket ad vissza, amely miatt a szaggatott tömb nem többdimenziós. Az egyes részarray elemeinek számát úgy határozhatja meg, hogy beolvassa az egyes részarray tulajdonságának Array.Length értékét. Az alábbi példa bemutatja, hogyan határozható meg a szaggatott tömb elemeinek száma.

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

Nulla hosszúságú tömbök

A Visual Basic különbséget tesz egy nem inicializált tömb (egy tömb, amelynek értéke Nothing) és egy nulla hosszúságú tömb vagy üres tömb (olyan tömb, amely nem tartalmaz elemeket.) Az nem inicializált tömbök olyan tömbök, amelyek nincsenek dimenziózva, vagy amelyekhez értékeket rendeltek. Például:

Dim arr() As String

A nulla hosszúságú tömbök deklarálása -1 dimenzióval történik. Például:

Dim arrZ(-1) As String

Előfordulhat, hogy nulla hosszúságú tömböt kell létrehoznia a következő körülmények között:

• Anélkül, hogy kivételt kockáztatna NullReferenceException, a kódnak hozzá kell férnie az Array osztály tagjaihoz, például Length vagy Rank, és egy Visual Basic-függvényt kell meghívnia, például UBound.

• A kódot egyszerűnek szeretné tartani, hogy ne kelljen különleges esetként ellenőriznie Nothing-t.

• A kód egy alkalmazásprogramozási felülettel (API) kommunikál, amely megköveteli, hogy nulla hosszúságú tömböt adjon át egy vagy több eljárásnak, vagy nulla hosszúságú tömböt ad vissza egy vagy több eljárásból.

Tömb felosztása

Egyes esetekben előfordulhat, hogy egyetlen tömböt több tömbre kell felosztania. Ez magában foglalja a tömb felosztási pontjainak azonosítását, majd a tömb két vagy több különálló tömbbe való felosztását.

Megjegyzés:

Ez a szakasz nem tárgyalja egyetlen sztring felosztását egy sztringtömbre valamilyen elválasztó alapján. A sztring felosztásával kapcsolatos információkért tekintse meg a metódust String.Split .

A tömbök felosztásának leggyakoribb feltételei a következők:

• A tömb elemeinek száma. Előfordulhat például, hogy egy megadott számú elemnél több tömböt szeretne felosztani körülbelül egyenlő számú részre. Erre a célra használhatja a visszaadott értéket vagy a Array.LengthArray.GetLength metódust.

• Egy elem értéke, amely elválasztóként szolgál, amely azt jelzi, hogy hol kell felosztani a tömböt. A metódusok meghívásával Array.FindIndexArray.FindLastIndex megkereshet egy adott értéket.

Miután meghatározta az indexeket vagy indexeket, amelyeken a tömböt fel kell osztani, a metódus meghívásával létrehozhatja az Array.Copy egyes tömböket.

Az alábbi példa egy tömböt körülbelül azonos méretű tömbökre osztja fel. (Ha a tömbelemek teljes száma páratlan, akkor az első tömbnek egynél több eleme van a másodiknál.)

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

Az alábbi példa egy sztringtömböt két tömbre oszt egy "zzz" értékű elem jelenléte alapján, amely tömbelválasztóként szolgál. Az új tömbök nem tartalmazzák a határolót tartalmazó elemet.

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

Tömbök összekapcsolása

Több tömböt egyetlen nagyobb tömbbe is kombinálhat. Ehhez a metódust is használhatja Array.Copy .

Megjegyzés:

Ez a szakasz nem tárgyalja a sztringtömbök egyetlen sztringbe való csatlakoztatását. A sztringtömbhöz való csatlakozással kapcsolatos információkért tekintse meg a metódust String.Join .

Mielőtt az egyes tömbök elemeit az új tömbbe másolta volna, először meg kell győződnie arról, hogy inicializálta a tömböt, hogy az elég nagy legyen az új tömb elhelyezéséhez. Ezt kétféleképpen teheti meg:

• ReDim Preserve Az utasítás használatával dinamikusan kibonthatja a tömböt, mielőtt új elemeket ad hozzá. Ez a legegyszerűbb technika, de nagy tömbök másolása esetén teljesítménycsökkenést és túlzott memóriahasználatot eredményezhet.
• Számítsa ki az új nagy tömbhöz szükséges elemek teljes számát, majd adja hozzá az egyes forrástömbök elemeit.

Az alábbi példa a második módszer segítségével négy tízelemű tömböt ad hozzá egyetlen tömbhöz.

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.

Mivel ebben az esetben a forrástömbök mind kicsik, dinamikusan bővíthetjük is a tömböt, miközben hozzáadjuk az egyes új tömbök elemeit. Az alábbi példa ezt teszi.

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.

Gyűjtemények tömbök alternatívaként

A tömbök akkor hasznosak, ha rögzített számú erősen beírt objektumot hoznak létre és dolgoznak fel. A gyűjtemények rugalmasabb módot biztosítanak az objektumcsoportok használatához. Ellentétben a tömbökkel, amelyek megkövetelik, hogy explicit módon módosítsa a tömb méretét az Utasítással, a ReDimgyűjtemények dinamikusan növekednek és zsugorodnak az alkalmazás igényeinek megfelelően.

Amikor a ReDim használatával átméretez egy tömböt, a Visual Basic létrehoz egy új tömböt, és felszabadítja az előzőt. Ez végrehajtási időt vesz igénybe. Ezért, ha gyakran változik az általad használt elemek száma, vagy nem tudod előre megjósolni, hogy hány elemre lesz szükséged maximálisan, általában jobb teljesítményt érhetsz el egy gyűjtemény használatával.

Egyes gyűjtemények esetében kulcsokat rendelhet a gyűjteménybe helyezett bármely objektumhoz, hogy gyorsan lekérhesse az objektumot a kulccsal.

Ha a gyűjtemény csak egy adattípus elemeit tartalmazza, használhatja a névtér egyik osztályát System.Collections.Generic . Egy általános gyűjtemény a típusbiztonságot kényszeríti ki, hogy ne lehessen más adattípust hozzáadni.

A gyűjteményekről további információt a Gyűjtemények című témakörben talál.

Kapcsolódó témakörök

Időszak	Definíció
Tömbdimenziók a Visual Basicben	A tömbök rangját és dimenzióit ismerteti.
Útmutató: Tömbváltozó inicializálása a Visual Basicben	A tömbök kezdeti értékekkel való feltöltésének módját ismerteti.
Útmutató: Tömb rendezése a Visual Basicben	Bemutatja, hogyan rendezheti a tömb elemeit betűrendben.
Útmutató: Tömb hozzárendelése egy másik tömbhöz	A tömb egy másik tömbváltozóhoz való hozzárendelésének szabályait és lépéseit ismerteti.
Tömbök hibaelhárítása	A tömbök használatakor felmerülő gyakori problémák ismertetése.

Lásd még

• System.Array
• Dim utasítás
• ReDim utasítás