Hoofdstuk 9: Arrays

Inleiding

Een array variabele is een verwijzing naar een grote verzameling van gegevens

• In veel programma's moeten er grote hoeveelheden gegevens opgeslaan en verwerkt worden. Zo kan je bijvoorbeeld 100 meetwaarden binnenlezen en hun gemiddelde berekenen en de waarden weten die boven het gemiddelde zijn. Een eerste programma leest de getallen, een tweede bepaalt het gemiddelde en een derde zoekt uit hoeveel waarde er boven het gemiddelde zijn.

• Als je 100 getallen moet inlezen, zou je (als je nog niets van arrays weet) die moeten opslaan in 100 variabelen. Dit is heel omslachtig en heel onpraktisch.

• In dergelijke gevallen hebben we nood aan een tool die ons toelaat een groot aantal waarden van hetzelfde type te kunnen opslaan en deze gemakkelijk te kunnen ophalen. Java en veel andere programmeertalen voorzien een gegevensstructuur (of datastructuur), de array, dat een opeenvolgende verzameling van elementen van het zelfde type kan bevatten. Een dergelijke array kan je zien als een opeenvolging van vakjes waarin je waarden kan in opslaan. De vakjes hebben een nummer, die we index noemen en het totaal aantal vakjes noemen we de grootte van de array. De grootte van de array bepaald hoeveel waardes we kunnen opslaan.

Programmeren van arrays

Wanneer een array gecreëerd is, blijft zijn grootte hetzelfde. Een verwijzing naar de array wordt gebruikt om de elementen op te halen via een index

• Een getal wordt gebruikt om een grote hoeveelheid gegevens in op te slaan, maar het is gemakkelijker om een array te zien als een verzameling van variabelen van hetzelfde type. In plaats van individuele variabelen te declareren zoals: getal0, getal1, ... getal99, kan je een array variabele declareren zoals getal en om waardes van die array ophalen door getal[0], getal[1] en getal[99]

Declaratie van een arry

• Om een array te gebruiken moet je een variabele laten verwijzen naar die array. Je moet Java laten weten dat die variabele een verwijzing is naar een array, en je moet ook specifiëren welke types in die array zullen zitten. De syntax om een array variabele te declareren is als volgt:

elementType[] arrayNaam;

waarbij elementType moet vervangen worden door een type (bv. int, double,char,String,...) en een arrayNaam moet vervangen worden door een goed gekozen naam voor een array (bv. rijgetallen, meetwaarden,... )

• Bijvoorbeeld

• Let op: de declaratie van arrays maakt nog niet dat je ze kan gebruiken. Je moet de rij nu nog gaan creëren. Dit niet zoals de declaratie van een int variabele, waarbij het geheugen van de variabele reeds gemaakt wordt (gealloceerd) bij de declaratie.

Creatie van arrays

• Een belangrijk verschil bij het declareren van variabelen van een bepaald type is dat de declaratie van een array variabele geen geheugen alloceerd (vrijmaakt) voor de array. De declaratie maakt enkel een verwijzing en laat Java weten dat de array variabele wijst naar een array. Initieel heeft de waarde van een array variabele, zoals mijnLijst, null. We kunnen de array nog niet gebruiken om waardes in op te slaan en we moeten dus nog die array maken. De gebeurt via het sleutelwoord new:

arrayNaam = new elementType[arrayGrootte];

Hierbij moet arrayGrootte vervangen worden door een getal die zegt hoeveel waardes er in de array kunnen opgeslaan worden.

• De bovenstaande uitdrukking voert twee zaken uit:

  • Het creëert een array door new elementType[arrayGrootte]
  • Het kent de referentie naar die gecreërde array toe aan de variabele arrayNaam

• Heel vaak, wordt de declaratie en de creatie van een array variabele uitgevoerd in één uitdrukking:

elementType[] arrayNaam = new elementType[arrayGrootte];

• Het volgende voorbeeld declareert en maakt een array van 10 kommagetallen:

Grootte van de array en default waarden

• Wanneer de geheugenruimte in de computer vrijgemaakt is voor een array van een bepaalde grootte, kunnen een aantal elementen opgeslaan worden. De grootte van een array kan niet veranderd worden nna de creatie van de array. De grootte van de array kan opgevraagd worden door gebruik te maken van arrayNaam.length. Bijvoorbeeld zo geeft de uitdrukking mijnLijst.length de waarde 10 terug.
• Wanneer een array gecreëerd wordt, worden de waardes van de elementen geïnitialiseerd op hun default waarde: 0 voor getallen, \u0000 voor char types en false voor het type boolean.

Elementen van een array opvragen

• De elementen van een array kunnen opgevraagd worden aan de hand van een index. Indices van een array starten vana 0. Dus de index van een array gaat van 0 tot arrayNaam.length - 1. In het voorbeeld bewaart mijnLijst 10 getalwaarden, dus de index gaat van 0 tot 9.
• Elk element in een array wordt voorgesteld door de volgende syntax, ook gekend als een geïndexeerde variabele:

arrayNaam[index];

• Bijvoorbeeld, mijnLijst[9] stelt het laatste getal voor in de array mijnLijst.

• Opgelet: sommige programmeertalen gebruiken ronde haakjes om een waarde op te vragen mijnLijst(9), Java gebruikt rechte haakjes mijnLijst[9].

• Een geïndexeerde variabele kan op dezelfde manier gebruikt worden als een gewone variabele. Zo kan je bijvoorbeeld de waarde op de eerste en tweede plaats optellen en ze bewaren op de derde plaats. De eerste plaats in een array heeft index 0:

• Het volgend stukje code gaat waardes toekennen aan de array met behulp van een lus:

Initializatie van een array

• Een initializatie van een array kan in Java gebeuren via een verkorte manier: array initializatie, waarbij declaratie, creatie en initializatie gecombineerd worden in één Java-uitdrukking:

elementType[] arrayNaam = {waarde0, waarde1, waarde2, ...,waardek};

• bijvoorbeeld:

• Bovenstaande uitdrukking declareert, creëert en initializeert de array mijnLijst met 4 elementen. De code is equivalent met:

• Let op! - bij array initializatie wordt de new operator niet gebruikt. De array initializatie zal dit impliciet (i.e. zonder dat je het beseft) doen, want je gaat declaratie, creatie en initializatie in één uitdrukking doen. De array initializatie splitsen zal een syntax fout geven. Het volgende is dus fout:

Verwerken van arrays

• Bij het verwerken van een array wordt meestal een for-lus gebruikt:

  • Alle elementen in een array zijn van hetzelfde type, dus kunnen ze op dezelfde manier verwerkt worden
  • Gezien de grootte van de array gekend is.

• Veronderstel dat de array gecreëerd wordt als volgt:

De volgende codefragmenten zijn voorbeelden om arrays te verwerken:

1. Initializatie van arrays met invoer waarden: De volgende lus zal de array mijnLijst initializeren met invoerwaarden van de gebruiker.

   Scanner invoer = new Scanner(System.in); System.out.print("typ " + mijnLijst.length + " waardes: "); for (int i = 0; i < mijnLijst.length; i++){ mijnLijst[i] = invoer.nextDouble(); }
   

1. Initializatie van arrays met willekeurige waarden: De volgende lus zal de array mijnLijst initializeren met willekeurige waarden genereerd tussen 0 en 100.0 (100.0 niet inclusief).

   for (int i = 0; i < mijnLijst.length; i++){ mijnLijst[i] = Math.random()*100; }
   

2. Uitprinten van arrays: Om een array op het scherm te tonene, moet je elke element opvragen en op het scherm tonen.

   for (int i = 0; i < mijnLijst.length; i++){ System.out.print(mijnLijst[i] + " "); }
   

3. Sommeren van alle elementen in een array: Gebruik een variabele totaal om de som van de elementen op te slaan. Initieel is totaal gelijk aan 0. Voeg de waarde van elk element in de array toe aan totaal in een lus:

   double totaal = 0; for (int i = 0; i < mijnLijst.length; i++){ totaal += mijnLijst[i]; }
   

4. Vind het grootste element in de array: Gebruik een variabele maximum om het grootste element in op te slaan. Initieel is maximum gelijk aan mijnLijst[0]. Om het grootste element te vinden, vergelijk elk element in de rij met maximum. Als de waarde van het element groter is dan maximum dan wordt maximum gelijk aan de nieuwe waarde.

   double maximum = mijnLijst[0]; for (int i = 1; i < mijnLijst.length; i++){ if (mijnLijst[i] > maximum){ maximum = mijnLijst[i]; } }
   

5. Vind de kleinste index van het grootste element in de array: Soms moet je ook weten waar in de array het maximum voorkomt. Als een array meerdere elementen zijn met dezelfde maximale waarde, wat is dan de kleinste index ervan. Veronderstal dat mijnLijst gelijk is aan {1,5,3,4,5,2}. Het grootste element is 5 en de kleinste index van 5 is 1 (de array start vanaf 0). Gebruik een variabele maximum om de grootste waarde in op te slaan en een variabele indexMaximum om de index van het grootste element in op te slaan. Initieel is maximum gelijk aan mijnLijst[0] en indexMaximum gelijk aan 0. Vergelijk elk element in mijnLijst met maximum en update maximum en indexMaximum indien het element groter is dan maximum

   double maximum = mijnLijst[0]; int indexMaximum = 0; for (int i = 1; i < mijnLijst.length; i++){ if (mijnLijst[i] > maximum){ maximum = mijnLijst[i]; indexMaximum = i; } }
   

6. Willekeurige volgorde: In veel toepassingen, moeten we elementen herordenen in een willekeurige volgorde (Eng. to shuffle). Om dit te doen moeten we voor elk element in de array mijnLijst[i] een willkeurige index genereren en de elementen mijnLijst[i] en mijnLijst[j] omwisselen:

   for (int i = mijnLijst.length -1; i > 0; i--){ //Genereer een index j willekeurig tussen 0 <= j < i int j = (int)(Math.random()*(i+1)); //Wissel mijnLijst[i] en mijnLijst[j] om double temp = mijnLijst[i]; mijnLijst[i]=mijnLijst[j]; mijnLijst[j]=temp; }
   

1. Opschuiven van elementen: In veel audiotoepassingen moeten we de elementen in een rij een plaatsje naar links of naar rechts opschuiven. Hier is een voorbeeld waarbij we delementen van een array naar links opschuiven en waarbij het eerste element in de rij terug naar achter wordt geplaatst.

   

   double temp = mijnLijst[0]; //Schuif op naar links for (int i = 1; i < mijnLijst.length; i++){ mijnLijst[i-1] = mijnLijst[i]; }
   

2. Vereenvoudigen van code: Arrays kunnen gebruikt worden om sommige code te vereenvoudigen. Bijvoorbeeld stel dat je Engelstalige naam van een maand wil nemen via zijn getal (bv. maand 3 is "March"). Je kan de benamingen in een Array opslaan en de naam opvragen via de index.

   String[] maandenEngels = {"January", "February", ... , "December"}; System.out.print("Voer het nummer van de maand in (1 tot 12): "); int maandNummer = invoer.nextInt(); System.out.println("De Engelstalige naam van de maand is " + maandenEngels[maandNummer - 1]);
   

Toepassing: Sorteren