Tot nu toe bewaarde elke variabele precies één waarde. Maar wat als je tien getallen wil bijhouden, of de scores van een hele klas? Dan zou je tien aparte variabelen moeten declareren, en dat wordt al snel onhandig. Daarvoor bestaat de array.

Een array is een rij van waarden van hetzelfde type. Je kan er bijvoorbeeld een rij gehele getallen in bewaren, of een rij double’s, of een rij strings, maar nooit door elkaar: alle waarden in één array hebben hetzelfde datatype.

Een array declareren

Aan iedere waarde in een array wordt een index toegekend. De index is een volgnummer dat begint bij 0 en telkens met 1 verhoogt voor elk volgend element. Dat is even wennen: het eerste element heeft index 0, niet 1.

Je declareert een array door vierkante haken [] achter het datatype te zetten. Met new int[5] maak je de array ook echt aan, met plaats voor 5 gehele getallen:

int[] a = new int[5];

Vergelijk een array met een ladenkast met vijf schuiven. Op elke schuif plakken we het nummer van de schuif. Dat nummer hebben we nodig om de juiste schuif te openen en bij de inhoud te raken. Het nummer van de schuif noemen we de index. De eerste schuif heeft index 0.

Voor datatypes die getallen zijn, krijgen alle elementen meteen de beginwaarde 0. Na new int[5] ziet de array er dus zo uit:

Een element aanspreken

Je leest of wijzigt een element door de index tussen vierkante haken te zetten:

a[0] = 12;          // het eerste element krijgt de waarde 12
a[4] = 7;           // het laatste element krijgt de waarde 7
Console.WriteLine(a[0]);   // toont 12

Let op: een array met 5 elementen heeft indexen 0 tot en met 4. Er is dus geen a[5]. Probeer je toch een index buiten de array aan te spreken, dan loopt je programma vast.

Hoeveel elementen zitten er in?

De array weet zelf hoeveel elementen hij bevat. Met a.Length vraag je dat aantal op. In ons voorbeeld is a.Length gelijk aan 5.

Let op het verschil: a.Length telt vanaf 1 (het aantal elementen), terwijl de index vanaf 0 telt. De grootste geldige index is dus altijd a.Length - 1.

Er bestaat ook a.GetUpperBound(0): die geeft je rechtstreeks de hoogste index van de array (voor onze a dus 4), wat net hetzelfde is als a.Length - 1. Voor een gewone array gebruik je meestal Length; GetUpperBound wordt vooral handig bij arrays met meerdere dimensies (zie het volgende hoofdstuk).

Een array doorlopen met een for-lus

Omdat we vaak elk element één voor één willen behandelen, en omdat we via a.Length exact weten hoeveel elementen er zijn, is een for-lus de natuurlijke keuze. We laten de teller i lopen van 0 tot en met a.Length - 1:

// declaratie van variabelen
int[] a = new int[5];

// doorloop de array element per element
for (int i = 0; i < a.Length; i++)
{
    Console.WriteLine(a[i]);
}

In de voorwaarde gebruiken we i < a.Length. Zo loopt i van 0 tot en met 4, precies de geldige indexen. Zouden we i <= a.Length schrijven, dan zouden we a[5] proberen aanspreken, en dat bestaat niet.

Net na new int[5] zijn alle elementen nog 0, dus dit programma toont vijf nullen, elk op een eigen regel:

0
0
0
0
0

Een uitgewerkt voorbeeld

Laten we de array eerst vullen en daarna doorlopen. We bewaren de eerste vijf oneven getallen en tonen ze samen met hun index:

// declaratie en aanmaak van de array
int[] getallen = new int[5];

// vul de array
getallen[0] = 1;
getallen[1] = 3;
getallen[2] = 5;
getallen[3] = 7;
getallen[4] = 9;

// doorloop de array en toon elk element met zijn index
for (int i = 0; i < getallen.Length; i++)
{
    Console.WriteLine("Element " + i + " is " + getallen[i]);
}

Dit toont:

Element 0 is 1
Element 1 is 3
Element 2 is 5
Element 3 is 7
Element 4 is 9

Merk op hoe de teller i twee rollen speelt: hij is zowel de index waarmee we het element aanspreken (getallen[i]) als het volgnummer dat we tonen. Dat is typisch voor het werken met arrays.

Nog enkele opmerkingen

Een array heeft een vaste grootte: eens je new int[5] schrijft, blijft die array vijf elementen groot. Wil je ze achteraf toch groter of kleiner maken, dan bestaat daar de functie Array.Resize voor.

Daarnaast zijn er nog heel wat andere functies om met arrays te werken. Heb je iets specifieks nodig, dan loont het om even op te zoeken of er al een kant-en-klare functie voor bestaat.

Onthoud de drie kernideeën van een array: het is een rij waarden van hetzelfde type, de index begint bij 0, en met Length ken je het aantal elementen. Met een for-lus van 0 tot Length - 1 doorloop je ze allemaal.