HOOFDSTUK 7 ARRAYS 7.1.     INLEIDING Array is een datastructuur waarin je een aantal referenties of waarden van hetzelfde primitieve type bij elkaar kunt opbergen  je kan geen waarden van verschillende typen in één array opslaan. is een static entiteit: eenmaal de array is gecreëerd, behoudt ze dezelfde grootte.

7.2. TERMINOLOGIE elementen van een array = de referenties of de waarden die in een array zijn opgeborgen elk element heeft een nummer, de index van dat element. lengte of de grootte van een array = aantal elementen dat je maximaal in een array kan opbergen.

In het geheugen van de computer ziet de array c er als volgt uit: index array c naam van element In het geheugen van de computer ziet de array c er als volgt uit: c[ 0 ] -45 6 72 1543 -89 62 -3 1 6453 78 1 c[ 1 ] 2 c[ 2 ] 3 c[ 3 ] 4 c[ 4 ] 5 c[ 5 ] 6 c[ 6 ] 7 c[ 7 ] 8 c[ 8 ] 9 c[ 9 ] 10 c[ 10 ] 11 c[ 11 ] De array c bestaat uit 12 elementen. M.a.w. de lengte van de array c is 12.

ELEMENTEN VAN DE ARRAY De naam van de array is c. De array c heeft 12 elementen. Met behulp van de naam van de array en de index krijgt elk element zijn eigen naam, in ons voorbeeld c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10] en c[11].

De waarde van het eerste element is –45. ELEMENTEN VAN DE ARRAY Het eerste element van de array is c[0]. Het tweede element van de array is c[1]. Het achtste element van de array is c[7]. De waarde van het eerste element is –45. index array c naam van element c[ 0 ] -45 6 … 1 c[ 1 ] … …

De index begint altijd bij nul. De index staat tussen vierkante haakjes. De index moet een geheel getal zijn of een ‘integer expressie’. Bv. a = 5; b = 6; c[a+b] += 2;  De waarde van c[11] wordt met 2 verhoogd. Het resultaat komt in c[11] terecht.

OBJECT-VARIABELE length Elke array kent zijn lengte. Via de public object-variabele length kan je steeds het maximale aantal elementen van een array opvragen. In ons voorbeeld: c.length (= 12) length is geen methode, dus we mogen niet schrijven: length().

PRIORITEITEN Haakjes ([], ()) hebben de hoogste prioriteit. Bv. c[1 + 3] = 10 + 2 * 4 - (2 – 1) c[4] = 10 + 2 * 4 - 1 c[4] = 10 + 8 - 1 c[4] = 17

een array-object creëren  operator new. 7.3. DECLARATIE EN CREATIE Arrays zijn objecten die je kan doorgeven en gebruiken net als andere objecten. Om een array te gebruiken, dien je een variabele te declareren, een array-object te creëren en de variabele doen verwijzen naar het array-object. een array-object creëren  operator new. int c[]; // een variabele declareren die naar // een array-object kan verwijzen. c = new int[ 12 ]; // een array-object creëren // en er met de variabele naar verwijzen. OF de twee acties combineren: int c[] = new int[ 12 ];

CREATIE VAN ARRAY-OBJECT De programmeur vermeldt bij het creëren van een array-object: het type van de elementen van de array de grootte van de array. In ons voorbeeld: int en 12 int c[]; c = new int[ 12 ]; OF int c[] = new int[ 12 ];

VOORBEELD DECLARATIE eerste vorm van declaratie: int a[], b[], c[]; tweede vorm van declaratie: int[] a, b, c; in beide gevallen: a, b en c zijn variabelen die naar een array kunnen verwijzen.

VOORBEELD DECLARATIE EN CREATIE double[] a, b; a = new double[ 10 ]; b = new double[ 20 ]; OF double[] a = new double[ 10 ]; double[] b = new double[ 20 ]; double[] a = new double[ 10 ] ,

INITIALISATIE VAN ELEMENTEN VAN ARRAY Elk element van de array wordt automatisch geïnitialiseerd. In ons voorbeeld (int c[] = new int[ 12 ];): alle elementen van de array krijgen de waarde nul (integerarray). elementen van array zijn booleans  false elementen van array zijn objecten  null bv. array van objecten String b[] = new String[ 100 ];

REFERENTIES int c[]; c = new int[ 12 ]; OF int c[] = new int[ 12 ]; c is een variabele dat naar een array-object verwijst. M.a.w. c is een referentie. c 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 10 11

De array initialiseren 7.4 VOORBEELDEN De array initialiseren  aan elk element van de array een specifiek getal toekennen. int array[] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37}; Elk element van de array komt overeen met het element uit de initialisatie-lijst.

7 public static void main( String args[] ) 8 { 1 // Fig. 7.3: InitArray.java 2 // Een array initïaliseren. 3 import javax.swing.*; 4 5 public class InitArray 6 { 7 public static void main( String args[] ) 8 { 9 // de array initïaliseren: aan elk element van de array 10 // een speciefieke waarde toekennen 11 int array[] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 }; 12 13 String output = "Subscript\tValue\n"; 14 // elke waarde van de elementen van de array worden 15 // in String output achteraan toegevoegd. 16 for ( int counter = 0; counter < array.length; counter++ ) 17 output += counter + "\t" + array[ counter ] + "\n"; 18 19 JTextArea outputArea = new JTextArea(); 20 outputArea.setText( output ); 21 22 JOptionPane.showMessageDialog( null, outputArea, 23 "Initializing an Array with a Declaration", 24 JOptionPane.INFORMATION_MESSAGE ); 25 26 System.exit( 0 ); 27 28 } // einde main 29 30 } // einde klasse InitArray

De elementen van de array initialiseren 9 // de array initïaliseren: aan elk element van de array 10 // een speciefieke waarde toekennen 11 int array[] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37}; De elementen van de array initialiseren De items staan tussen accolades ({}) Items in de lijst worden gescheiden door komma’s int n[] = { 10, 20, 30, 40, 50 }; Creëert een array, bestaande uit 5 elementen. n 10 20 30 40 50 0 1 2 3 4 De operator new is niet nodig.

array.length geeft de grootte van de array weer. Lijn 17 13 String output = "Subscript\tValue\n"; 14 // elke waarde van de elementen van de array worden 15 // in String output achteraan toegevoegd. 16 for ( int counter = 0; counter < array.length; counter++ ) 17 output += counter + "\t" + array[ counter ] + "\n"; Lijn 16 array.length geeft de grootte van de array weer. Lijn 17 array[counter] bevat de waarde van het element met index counter.

De array, bestaande uit 10 elementen, opvullen met even getallen van 2 tot 20. De grootte van de array toekennen aan een constante en vervolgens enkel gebruik maken van deze constante in de rest van de code! VOORBEELD 2

7 public static void main( String args[] ) 8 { 1 // Fig. 7.4: InitArray.java 2 // Een array opvullen met de even nummers van 2 tot 20. 3 import javax.swing.*; 4 5 public class InitArray 6 { 7 public static void main( String args[] ) 8 { 9 final int ARRAY_SIZE = 10; 10 int array[]; 11 12 array = new int[ ARRAY_SIZE ]; 13 14 // waarde berekenen voor elk element van de array 15 for ( int counter = 0; counter < array.length; counter++ ) 16 array[ counter ] = 2 + 2 * counter; 17 18 String output = "Subscript\tValue\n"; 19 20 for ( int counter = 0; counter < array.length; counter++ ) 21 output += counter + "\t" + array[ counter ] + "\n"; 22 23 JTextArea outputArea = new JTextArea(); 24 outputArea.setText( output ); 25 26 JOptionPane.showMessageDialog( null, outputArea, 27 "Initializing to Even Numbers from 2 to 20", 28 JOptionPane.INFORMATION_MESSAGE ); 29 30 System.exit( 0 ); 31 32 } // einde main 33 34 } // einde klasse InitArray

de constante ARRAY_SIZE wordt gedeclareerd. Lijn 10 9 final int ARRAY_SIZE = 10; 10 int array[]; 11 12 array = new int[ ARRAY_SIZE ]; Lijn 9 de constante ARRAY_SIZE wordt gedeclareerd. Lijn 10 array wordt gedeclareerd. array kan verwijzen naar een array-object, die uit ints zal bestaan. Lijn 12 array verwijst naar een array-object, die uit 10 ints bestaat. Elk element van array wordt geïnitialiseerd met de waarde 0.

14 // waarde berekenen voor elk element van de array 15 for ( int counter = 0; counter < array.length; counter++ ) 16 array[ counter ] = 2 + 2 * counter; Lijn 16 de teller counter wordt gebruikt om de elementen van de array op te vullen. counter = 0 array[0] = 2 + 2 * 0 = 2 counter = 1 array[1] = 2 + 2 * 1 = 4 counter = 2 array[2] = 2 + 2 * 2 = 6 etc.

Vind de fout(en) in volgende stukjes code: OEFENING Vind de fout(en) in volgende stukjes code: 1. final int MAX = 3; int table[MAX] = {1,2,3}; Int table[] = {1,2,3} 2. int max = 5; int table1[] = new int [max]; table1[max] = 5; max++; int table2[] = new short [max];

Een histogram weergeven. Bv. int array[] = {2, 5, 3} dan wordt er weergegeven: Element Value Histogram 0 2 ** 1 5 ***** 2 3 *** VOORBEELD 3

2 // Histogram weergeven. 3 import javax.swing.*; 4 1 // Fig. 7.6: Histogram.java 2 // Histogram weergeven. 3 import javax.swing.*; 4 5 public class Histogram 6 { 7 public static void main( String args[] ) 8 { 9 int array[] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 }; 10 11 String output = "Element\tValue\tHistogram"; 12 13 // voor elk element, een histogram maken (rij van *) 14 for ( int counter = 0; counter < array.length; counter++ ) 15 { 16 output += "\n" + counter + "\t" + array[ counter ] + "\t"; 17 // ouput opvullen met een aantal * 18 for ( int stars = 0; stars < array[ counter ]; stars++ ) 19 output += "*"; 20 21 } // einde for 22 23 JTextArea outputArea = new JTextArea(); 24 outputArea.setText( output ); 25 26 JOptionPane.showMessageDialog( null, outputArea, 27 "Histogram Printing Program", JOptionPane.INFORMATION_MESSAGE ); 28 29 System.exit( 0 ); 30 31 } // einde main 32 33 } // einde klasse Histogram

Lijn 14-21 geneste for-lussen. 9 int array[] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 }; 10 11 String output = "Element\tValue\tHistogram"; 12 13 // voor elk element, een histogram maken (rij van *) 14 for ( int counter = 0; counter < array.length; counter++ ) 15 { 16 output += 17 "\n" + counter + "\t" + array[ counter ] + "\t"; 18 // ouput opvullen met een aantal * 19 for ( int stars = 0; stars < array[ counter ]; stars++ ) 20 output += "*"; 21 } // einde for Lijn 14-21 geneste for-lussen. Lijn 20: output wordt gevuld met een aantal *. Het aantal * komt overeen met de waarde van het element van de array. Bv. array[1] (=3)  output += ***

Een teerling wordt 6000 keer geworpen Een teerling wordt 6000 keer geworpen. Er wordt weergegeven hoeveel keer 1 werd geworpen, hoeveel keer 2, …, hoeveel keer 6. We gebruiken een frequentietabel (= tabel, waarbij elk element een teller voorstelt). VOORBEELD 4

1 // Fig. 7.7: RollDie.java 2 // werp een teerling 6000 keer 3 import javax.swing.*; 4 5 public class RollDie 6 { 7 public static void main( String args[] ) 8 { 9 int frequency[] = new int[ 7 ]; 10 11 // werp de teerling 6000 keer 12 for ( int roll = 1; roll <= 6000; roll++ ) 13 ++frequency[ 1 + ( int ) ( Math.random() * 6 )]; 14 15 String output = "Face\tFrequency"; 16 17 // het resultaat van de 6000 worpen in output zetten 18 for ( face = 1; face < frequency.length; face++ ) 19 output += "\n" + face + "\t" + frequency[ face ]; 20 21 JTextArea outputArea = new JTextArea(); 22 outputArea.setText( output ); 23 24 JOptionPane.showMessageDialog( null, outputArea, 25 "Rolling a Die 6000 Times",JOptionPane.INFORMATION_MESSAGE ); 26 27 System.exit( 0 ); 28 29 } // einde main 30 31 } // einde klasse RollDie

9 int frequency[] = new int[ 7 ]; 11 // werp de teerling 6000 keer 12 for ( int roll = 1; roll <= 6000; roll++ ) 13 ++frequency[1 + ( int ) ( Math.random() * 6 )]; Lijn 9 frequency verwijst naar een array-object, bestaande uit 7 elementen, die allemaal op nul geïnitialiseerd zijn! Lijn 13 ++frequency[1 + ( int ) ( Math.random() * 6 )]; = int randomGetal = 1 + ( int ) ( Math.random() * 6 ); ++frequency[randomGetal]; een random getal tussen 1 en 6 wordt gegenereerd. Dit random getal wordt als index gebruikt. Het element van de array frequency, met deze index, wordt met 1 verhoogd.

40 studenten geven een schaal tussen 1 en 10 in, over het kwaliteit van het eten. 1 betekent afschuwelijk 10 betekent excellent De 40 antwoorden bevinden zich in een array. De schaal tussen 1 en 10 en de overeenkomstige resultaten worden weergegeven. VOORBEELD 5

1 // Fig. 7.8: StudentPoll.java 2 // Student poll program 3 import javax.swing.*; 4 5 public class StudentPoll 6 { 7 public static void main( String args[] ) 8 { 9 int responses[] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1, 6, 3, 8, 6, 10 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6, 5, 6, 7, 5, 6, 11 4, 8, 6, 8, 10 }; 12 int frequency[] = new int[ 11 ]; 13 14 // voor elk antwoord, gebruik de waarde van het element en 15 // gebruik deze waarde als index voor de array frequency. Het 15 // element van frequency op deze index wordt met 1 verhoogd. 16 for ( int answer = 0; answer < responses.length; answer++ ) 17 ++frequency[ responses[ answer ] ]; 18 19 String output = "Rating\tFrequency\n"; 20 21 // frequencies worden toegevoegd aan de String output 22 for ( int rating = 1; rating < frequency.length; rating++ ) 23 output += rating + "\t" + frequency[ rating ] + "\n"; 24 25 JTextArea outputArea = new JTextArea(); 26 outputArea.setText( output ); 27 28 JOptionPane.showMessageDialog( null, outputArea, 29 "Student Poll Program", JOptionPane.INFORMATION_MESSAGE ); 30 31 System.exit( 0 ); 32 33 } 34 35 }

declaratie van responses. 9 int responses[] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 10 1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 11 6, 6, 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 }; 12 int frequency[] = new int[ 11 ]; Lijn 9 declaratie van responses. responses wordt gebruikt om de 40 antwoorden van de studenten bij te houden. Lijn 12 declaratie van frequency. frequency zal de resultaten van de schalen 1 t.e.m. 10 bijhouden. frequency[1] zal het resultaat van schaal 1 bijhouden  frequency[0] zal niet gebruikt worden!!!

responses[0] is gelijk aan 1, dan wordt frequency[1] met één verhoogd. 16 for ( int answer = 0; answer < responses.length; answer++ ) 17 ++frequency[ responses[ answer ] ]; Lijn 16/17 For-lus: answer: 0  40 answer = 0  responses[0] bevat het resultaat van de eerste student  responses[0] is een getal tussen 1 en 10. Dit getal wordt gebruikt als index voor de array frequency. responses[0] is gelijk aan 1, dan wordt frequency[1] met één verhoogd. answer = 1 … answer = 40  einde lus

Stel dat de programmeur de volgende for-lus schrijft: OPMERKINGEN Bv. int c[] = new int[ 5 ]; Stel dat de programmeur de volgende for-lus schrijft: for ( int teller = 0; teller <= c.length; teller++ )  geen compilerfout, wel fout in runtime  Java genereert ArrayIndexOutOfBoundsException (wordt behandeld in hoofdstuk 14 (exception handling)) Idem voor for ( int teller = -1; teller < c.length; teller++ ) Tijdens de uitvoering van het programma worden de grenzen (bounds) van de index van een array bewaakt.

OEFENINGEN Lees 10 gehele getallen in en plaats deze in een array. Lees vervolgens nog een getal A in. Druk op het scherm alle getallen uit de array af, die strikt groter zijn dan A. Initialiseer een tabel met de omzet per maand van warenhuis Carrefour. De omzetwaarden zijn respectievelijk: 360, 2100, 450, 1450, 650, 780, 321, 1200, 560, 1850, 960, 420. Druk vervolgens de laagste en de hoogste waarde van de omzet af en het nummer van de corresponderende maand.

7.5 ARGUMENTEN VAN EEN METHODE Er zijn twee manieren om argumenten door te geven aan methodes: Pass-by-value Een kopie van de waarden van de actuele argumenten wordt doorgegeven aan de parameters van de methode. De waarden van de actuele argumenten kunnen niet gewijzigd worden in de methode.

7.5 ARGUMENTEN VAN EEN METHODE Pass-by-reference De waarde van de actuele argumenten (= referenties) worden doorgegeven aan de methode. De methode kan de objecten waarnaar de referenties wijzen, wijzigen. De performantie is hoger dan bij pass-by-value, vermits er geen data moet gekopieerd worden.

ARGUMENTEN VAN EEN METHODE Pass-by-value Primitieve types: steeds BY VALUE Pass-by-reference Objecten: steeds BY REFERENCE In Java, arrays zijn objecten  arrays: steeds BY REFERENCE

7.6 EEN ARRAY DOORGEVEN AAN EEN METHODE De arraynaam zonder vierkante haakjes Bv. hourlyTemperatures werd als volgt gedeclareerd: int hourlyTemperatures[] = new int[ 24 ]; De methode opoepen: modifyArray( hourlyTemperatures ); De array hourlyTemperatures wordt doorgegeven aan de methode modifyArray

int hourlyTemperatures[] = new int[ 24 ]; modifyArray( hourlyTemperatures ); void modifyArray( int anHourlyTemperatures[]) { … }

VOORBEELD Een array en een element van een array doorgeven aan een methode. In de methode wordt de array en het element van de array gewijzigd. 1 // Fig. 7.9: PassArray.java 2 // Een array en een element van een array doorgeven aan een methode 3 import java.awt.Container; 4 import javax.swing.*; 5 6 public class PassArray extends JApplet 7 { 8 // applet initialiseren 9 public void init() 10 { 11 JTextArea outputArea = new JTextArea(); 12 Container container = getContentPane(); 13 container.add( outputArea ); 14

De elementen van de array initïaliseren. 15 int array[] = { 1, 2, 3, 4, 5 }; 16 17 String output = "Effects of passing entire array by reference:\n" + 18 "The values of the original array are:\n"; 19 20 // de oorspronkelijke elementen van de array toevoegen aan String output 21 for ( int counter = 0; counter < array.length; counter++ ) 22 output += " " + array[ counter ]; 23 Lijn 15 De elementen van de array initïaliseren. "array[]" werd gedefinieerd als een lokale variabele. Ze is enkel gekend in de methode init. Wenst men deze array in een andere methode te gebruiken dan dient men deze array door te geven aan de andere methode (zie lijn 24). Lijn 21/22 output = output + “1 2 3 4 5”

Lijn 24: De array “array” doorgeven aan de methode modifyArray 24 modifyArray( array ); // array doorgeven (pass-by-reference) 42 // elk element van de array vermenigvuldigen met 2 43 public void modifyArray( int array2[] ) 44 { 45 for ( int counter = 0; counter < array2.length; counter++ ) 46 array2[ counter ] *= 2; 47 } Lijn 24: De array “array” doorgeven aan de methode modifyArray Lijn 45/46: Elk element van de array wordt vermenigvuldigd met twee. 24 modifyArray( array ); // array doorgeven (pass-by-reference) 25 26 output += "\n\nThe values of the modified array are:\n"; 27 28 // de gewijzigde elementen van de array toevoegen aan String output 29 for ( int counter = 0; counter < array.length; counter++ ) 30 output += " " + array[ counter ]; Lijn 29/30 output = output + “2 4 6 8 10”

35 modifyElement( array[ 3 ] ); 49 // het argument met 2 vermenigvuldigen 50 public void modifyElement( int element ) 51 { 52 element *= 2; 53 } Lijn 35 Het element array[3] (= int) wordt doorgegeven aan de methode modifyElement (de waarde van array[3] is 8) Lijn 52 element = 8 * 2 = 16

Het object werd gewijzigd: pass-by-reference 35 modifyElement( array[ 3 ] ); 36 37 output += "\na[3] after modifyElement: " + array[ 3 ]; 38 outputArea.setText( output ); 39 40 } // einde methode init … 55 } // end class PassArray Het object werd gewijzigd: pass-by-reference Het primitieve datatype werd niet gewijzigd: pass-by-value

Rode draad H7 : OEFENING Schrijf de methode stortenOpEenRekening. Het argument is een array van Rekeningen. In deze methode wordt er een geheel getal ingegeven. Tevens wordt er een bedrag in euro ingegeven. Vervolgens wordt dit bedrag gestort op de rekening met index ‘ingegeven getal-1’. Er wordt gebruik gemaakt van de instantie-methode storten van de klasse Rekening. Schrijf de methode uitvoerSaldo. De saldo’s van al de Rekeningen worden op het scherm weergegeven. Er wordt gebruik gemaakt van de instantie-methode getSaldo van de klasse Rekening. Vul de methode main aan (zie volgende slide):

OEFENING Vul de methode main aan: … public class OefeningRekening { public static void main(String args[]) Rekening rekening[] = new Rekening[5]; for (int i=0; i<rekening.length; i++) rekening[i] = new Rekening(); //de methode stortenOpEenRekening oproepen: // de methode uitvoerSaldo oproepen:

7.7 SORTEERTECHNIEK Het sorteren van een rij getallen in stijgende volgorde bubblesort Grote waarden “stijgen” naar de top (= rechts) van de array, zoals luchtbelletjes in het water. Kleine waarden “zinken” naar de bodem van de array (= links).

ALGORITME VAN BUBBLESORT Bv. we wensen de array 10 2 8 1 in stijgende volgorde te sorteren. Stap 1: a[0] en a[1] vergelijken 10 > 2  a[0] en a[1] verwisselen  2 10 8 1 a[1] en a[2] vergelijken 10 > 8 a[1] en a[2] verwisselen  2 8 10 1 a[2] en a[3] vergelijken 10 > 1  a[2] en a[3] verwisselen  2 8 1 10

ALGORITME VAN BUBBLESORT Na stap 1: 2 8 1 10 Stap 2: a[0] en a[1] vergelijken 2 < 8 a[1] en a[2] vergelijken 8 > 1 a[1] en a[2] verwisselen  2 1 8 10 [ a[2] en a[3] vergelijken 8 < 10 ] Stap 3: a[0] en a[1] vergelijken 2 > 1  a[0] en a[1] verwisselen  1 2 8 10 [ a[1] en a[2] vergelijken 2 < 8 ]

De elementen van de array initialiseren. SORTEERTECHNIEK : BUBBLESORT 1 // Fig. 7.10: BubbleSort.java 2 // Een array sorteren in stijgende volgorde. 3 import java.awt.*; 4 import javax.swing.*; 5 6 public class BubbleSort extends JApplet 7 { 8 // applet initialiseren 9 public void init() 10 { 11 JTextArea outputArea = new JTextArea(); 12 Container container = getContentPane(); 13 container.add( outputArea ); 14 15 int array[] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 }; 16 17 String output = "Data items in original order\n"; 18 // de oorspronkelijke elementen van 19 // de array toevoegen aan String output 20 for ( int counter = 0; counter < array.length; counter++ ) 21 output += " " + array[ counter ]; 22 De elementen van de array initialiseren. Wenst men de lokale variabele "array[]" in een andere methode te gebruiken dan dient men deze array door te geven aan de andere methode (zie lijn 23).

De array “array” doorgeven aan de methode bubblesort 23 bubbleSort( array ); // array sorteren 24 25 output += "\n\nData items in ascending order\n"; 26 27 // append sorted\ array values to String output 28 for ( int counter = 0; counter < array.length; counter++ ) 29 output += " " + array[ counter ]; 30 31 outputArea.setText( output ); 32 33 } // einde methode init … 67 } // einde klasse BubbleSort De array “array” doorgeven aan de methode bubblesort

35 // De array sorteren in stijgende volgorde (volgens bubblesort) 36 public void bubbleSort( int array2[] ) 37 { 38 // aantal stappen 39 for ( int pass = 1; pass < array2.length; pass++ ) 40 { 41 // de elementen van de array doorlopen 42 for ( int element = 0; 43 element < array2.length - pass; 44 element++ ) 45 { 46 // twee elementen van de array vergelijken met elkaar en 47 // verwisselen indien het 1ste el. groter is dan het 2de el. 48 if ( array2[ element ] > array2[ element + 1 ] ) 49 swap( array2, element, element + 1 ); 50 51 } // end-for 52 53 } // end-for 54 55 } // einde methode bubbleSort

De methode ontvangt 3 formele parameters 57 // twee elementen van de array verwisselen 58 public void swap( int array3[], int first, int second ) 59 { 60 int hold; // tijdelijke hulpvariabele 61 62 hold = array3[ first ]; 63 array3[ first ] = array3[ second ]; 64 array3[ second ] = hold; 65 } Lijn 58 De methode ontvangt 3 formele parameters array3  pass by reference geheel getal first: index van het eerste element geheel getal second: index van het tweede element Bv. indien array3[first] gelijk is aan 7 en array3[second] gelijk is aan 5, dan zal de methode swap het getal 5 toekennen aan array3[first] en 7 aan array3[second].

PERFORMANTERE ALGORITME VAN BUBBLESORT OEFENING: Herschrijf de methode bubbleSort: Bv. we wensen de array 3 1 10 2 te sorteren. Stap 1: a[0] en a[3] vergelijken 3 > 2  a[0] en a[3] verwisselen  2 1 10 3 a[1] en a[3] vergelijken 1 < 3 a[2] en a[3] vergelijken 10 > 3  a[2] en a[3] verwisselen  2 1 3 10 Stap 2: a[0] en a[2] vergelijken 2 < 3 a[1] en a[2] vergelijken 1 < 3 Stap 3: a[0] en a[1] vergelijken 2 > 1  a[0] en a[1] verwisselen  1 2 3 10

7.8 ZOEKTECHNIEKEN Het zoeken van een getal in een rij getallen Twee zoektechnieken bespreken: Linear searching Binary searching

LINEAR SEARCH Elk element vergelijken met het te zoeken getal (search key) Indien “search key” is gevonden, return zijn index. Indien “search key” niet is gevonden, return –1. Nuttig bij kleine of niet gesorteerde arrays. Inefficiënt bij grote gesorteerde arrays.

ALGORITME VAN LINEAR SEARCH Bv. we wensen het getal 10 te zoeken in de array 2 3 10 12 Is a[0] = 10? m.a.w. is 2 = 10? Neen Is a[1] = 10? m.a.w. is 3 = 10? Neen Is a[2] = 10? m.a.w. is 10 = 10? Ja  return 2

ALGORITME VAN LINEAR SEARCH Ander vb. we wensen het getal 5 te zoeken in de array 10 15 2 8 Is a[0] = 5? m.a.w. is 10 = 5? Neen Is a[1] = 5? m.a.w. is 15 = 5? Neen Is a[2] = 5? m.a.w. is 2 = 5? Neen Is a[3] = 5? m.a.w. is 8 = 5? Neen  return -1

De array “array” wordt gecreëerd en opgevuld in de methode init. VOORBEELD: LINEAR SEARCH De array “array” is een object-variabele. Ze is gekend in alle methodes van de klasse LinearSearch. 1 // Fig. 7.11: LinearSearch.java 2 // zoektechniek: Linear search … 6 public class LinearSearch extends JApplet 7 implements ActionListener 8 { 9 private JLabel enterLabel, resultLabel; 10 private JTextField enterField, resultField; 11 private int array[]; 12 13 // initialisatie van applet's GUI 14 public void init() 15 { 39 array = new int[ 100 ]; 40 41 for ( int counter = 0; counter < array.length; counter++ ) 42 array[ counter ] = 2 * counter; 43 44 } // einde methode init De array “array” wordt gecreëerd en opgevuld in de methode init.

Lijn 70-71: verschillend van het boek! 59 // het te zoeken getal aan de gebruiker vragen. Vervolgens 60 // wordt de methode linearSearch opgeroepen. 61 public void actionPerformed( ActionEvent actionEvent ) 62 { 63 // we hadden ook "enterField.getText()" kunnen gebruiken 64 // om de inputstring op te halen 65 String searchKey = actionEvent.getActionCommand(); 66 67 // De array en het te zoeken getal worden doorgegeven 68 // aan de methode linearSearch. Het geheel getal element 69 // zal de index van het te zoeken getal of -1 ontvangen. 70 int element = 71 linearSearch( Integer.parseInt( searchKey ) ); Lijn 61 De methode actionPerformed wordt AUTOMATISCH opgeroepen indien de gebruiker op “enter” heeft gedrukt. Lijn 70-71: verschillend van het boek! Het te zoeken getal wordt doorgegeven aan de methode linearSearch. “element” zal de index van het te zoeken getal of –1 ontvangen.

72 73 // het resultaat weergeven 74 if ( element != -1 ) 75 resultField.setText( "Found value in element " + 76 element ); 77 else 78 resultField.setText( "Value not found" ); 79 } // einde methode actionPerformed 80 81 } // einde klasse LinearSearch

“search key” is gevonden, return zijn index. Lijn 57 45 // Verschillend van het boek 46 // het getal "key" zoeken in de object-variabele"array" 47 public int linearSearch( int key ) 48 { 49 // De elementen van de array doorlopen 50 for ( int counter = 0; counter < array.length; counter++ ) 51 52 // indien het element van de array gelijk is aan het te 53 // zoeken getal "key", return zijn index. 54 if ( array[ counter ] == key ) 55 return counter; 56 57 return -1; // het te zoeken getal niet gevonden 58 } Lijn 55 “search key” is gevonden, return zijn index. Lijn 57 “search key” niet gevonden, return -1.

OEFENING Initialiseer een array met 10 willekeurige gehele getallen. (De array is een lokale variabele.) Vraag vervolgens om een geheel getal in te voeren. Schrijf een methode, die het ingevoerde getal zoekt en verwijdert in de array. Voeg op het einde van de array aan met nullen. Voorbeeld: a={4,8,2,3,5,17,7,99,3,12} en getal = 3 a wordt a = { 4,8,2,5,17,7,99,12,0,0}

ALGORITME VAN BINARY SEARCHING Bv. we wensen het getal 6 te zoeken, uit een array van 10 elementen 1 3 5 6 8 10 12 15 18 20 stap 1: low = 0, high = 10 – 1 = 9 middle = (low + high) / 2 = (0 + 9) / 2 = 4 a[4] = 8 > 6  high = middle – 1 = 4 – 1 = 3 stap 2: low = 0, high = 3 middle = (0 + 3) / 2 = 1 a[1] = 3 < 6  low = middle + 1 = 2

ALGORITME VAN BINARY SEARCHING stap 3: low = 2, high = 3 middle = (2 + 3) / 2 = 2 a[2] = 5 < 6  low = middle + 1 = 3 stap 4: low = 3, high = 3 middle = (3 + 3) / 2 = 3 a[3] = 6 = 6  getal is gevonden

ALGORITME VAN BINARY SEARCHING Bv. we wensen het getal 13 te zoeken, uit een array van 10 elementen 1 3 5 6 8 10 12 15 18 20 stap 1: low = 0, high = 10 – 1 = 9 middle = (0 + 9) / 2 = 4 a[4] = 8 < 13  low = middle + 1 = 5 stap 2: low = 5, high = 9 middle = (5 + 9) / 2 = 7 a[7] = 15 > 13  high = middle – 1 = 6 stap 3: low = 5, high = 6 middle = (5 + 6) / 2 = 5 a[5] = 10 < 13  low = middle + 1 = 6 stap 4: low = 6, high = 6 middle = (6 + 6) / 2 = 6 a[6] = 12 < 13  low = middle + 1 = 7 low > high  het getal staat niet in de array.

BINARY SEARCHING 1 // Fig. 7.12: BinarySearch.java 2 // zoektechniek: Binary search 3 4 // Java core packages 5 import java.awt.*; 6 import java.awt.event.*; 7 import java.text.*; 8 9 // Java extension packages 10 import javax.swing.*; 11 12 public class BinarySearch extends JApplet 13 implements ActionListener { 14 15 private JLabel enterLabel, resultLabel; 16 private JTextField enterField, resultField; 17 private JTextArea output; 18 private String display = "";

21 22 // initialisatie van applet's GUI 23 public void init() 24 { 25 // "get content pane" en ken zijn layout toe aan FlowLayout 26 Container container = getContentPane(); 27 container.setLayout( new FlowLayout() ); 28 29 // "JLabel" en "JTextField" klaarzetten voor input van gebruiker 30 enterLabel = new JLabel( "Enter integer search key" ); 31 container.add( enterLabel ); 32 33 enterField = new JTextField( 10 ); 34 container.add( enterField ); 35 36 // registreer deze applet als "enterField's action listener" 37 enterField.addActionListener( this ); 38 39 // "JLabel" en "JTextField" klaarzetten om de resultaten weer te geven 40 resultLabel = new JLabel( "Result" ); 41 container.add( resultLabel ); 42

array verwijst naar een array-object, die uit 15 ints bestaat. 43 resultField = new JTextField( 20 ); 44 resultField.setEditable( false ); 45 container.add( resultField ); 46 47 // "JTextField" klaarzetten om de vergelijkingen weer te geven 48 output = new JTextArea( 6, 60 ); 49 output.setFont( new Font( "Monospaced", Font.PLAIN, 12 ) ); 50 container.add( output ); 51 52 // een array creëren en opvullen met even gehele getallen van 0 tot 28 53 int array = new int[ 15 ]; 54 55 for ( int counter = 0; counter < array.length; counter++ ) 56 array[ counter ] = 2 * counter; 57 58 } // einde methode init Lijn 53 array verwijst naar een array-object, die uit 15 ints bestaat. Lijn 55-56 array opvullen met even gehele getallen van 0 tot 28.

59 // het te zoeken getal aan de gebruiker vragen. Vervolgens 60 // de methode binarySearch oproepen. 61 public void actionPerformed( ActionEvent actionEvent ) 62 { 63 // we hadden ook "enterField.getText()" kunnen gebruiken 64 65 String searchKey = actionEvent.getActionCommand(); 66 67 // de string display initialiseren met tekst 68 display = "Portions of array searched\n"; 69 Lijn 61 De methode actionPerformed wordt AUTOMATISCH opgeroepen indien de gebruiker op “enter” heeft gedrukt.

70 // de methode binarySearch oproepen 71 int element = 72 binarySearch( array, Integer.parseInt( searchKey ) ); 73 74 output.setText( display ); 75 76 // het resultaat van de binary search weergeven 77 if ( element != -1 ) 78 resultField.setText( 79 "Found value in element " + element ); 80 else 81 resultField.setText( "Value not found" ); 82 83 } // einde methode actionPerformed Lijn 71-72 De array en het te zoeken getal worden doorgegeven aan de methode binarySearch. “element” zal de index van het te zoeken getal of –1 ontvangen. Lijn 77-81 Het resultaat van de methode binarySearch (= “element”) wordt weergegeven.

84 // methode binary search 85 public int binarySearch( int array2[], int key ) 86 { 87 int low = 0; // ondergrens 88 int high = array.length - 1; // bovengrens 89 int middle; // midden van de grenzen 90 91 // zolang de ondergrens kleiner of gelijk is aan bovengrens 92 while ( low <= high ) 93 { 94 // midden van de grenzen bepalen 95 middle = ( low + high ) / 2; 96 97 // de elementen van de array weergeven, waarvan hun 98 // index tussen de ondergrens en bovengrens liggen 99 buildOutput( array2, low, middle, high ); Lijn 92 Zolang de ondergrens “low” kleiner of gelijk is aan de bovengrens “high”, wordt er gezocht naar het te zoeken getal “key” in de array (lijn 93-117).

Lijn 102: het te zoeken getal “key” werd gevonden in de array 100 // indien te zoeken getal gelijk is aan element met index 101 // middle, return de index «middle» 102 if ( key == array[ middle ] ) 103 return middle; 104 105 // indien te zoeken getal < array[middle], nieuw bovenrens bepalen 106 else if ( key < array[ middle ] ) 107 high = middle - 1; 108 109 // indien te zoeken getal > element met index middle 110 // dan nieuw ondergrens bepalen 111 else 112 low = middle + 1; 113 }//einde while 114 115 return -1; // te zoeken getal niet gevonden 116 117 } // einde methode binarySearch Lijn 102: het te zoeken getal “key” werd gevonden in de array Lijn 106-107: array[middle] > key  high = middle – 1 Lijn 111-112: array[middle] < key  low = middle + 1

118 // de elementen weergeven waarvaan hun index 119 // tussen de ondergrens "low" en bovengrens "high" ligt 120 void buildOutput( int array3[], 121 int low, int middle, int high ) 122 { 123 // creëer "2-digit integer number format" 124 DecimalFormat twoDigits = new DecimalFormat( "00" ); 125 126 // alle elementen van de array doorlopen 127 for ( int counter = 0; counter < array3.length; 128 counter++ ) 129 { Lijn 120-150: De methode buildOutput geeft de elementen van de array weer, die nog niet werden geëlimineerd door de binary search.

130 // indien de teller "counter" buiten de grenzen 131 // liggen dan spaties aan de String "display" toekennen 132 if ( counter < low || counter > high ) 133 display += " "; 134 135 // indien de teller "counter" gelijk is aan middle dan, 136 // het element met index middle en (*) aan "display" toekennen 137 else if ( counter == middle ) 138 display += 139 twoDigits.format( array3[ counter ] ) + "* "; 140 141 // het element met index "counter" aan display toekennen 142 else 143 display += 144 twoDigits.format( array3[ counter ] ) + " "; 145 146 } // einde for 147 148 display += "\n"; 149 150 } // einde methode buildOutput 151 152} // einde klasse BinarySearch

7.9 TWEE-DIMENSIONALE ARRAY bestaat uit rijen en kolommen is een datastructuur waarin je een zelfde soort gegevens kunt opslaan, zoals waarden van een bepaald primitief type of referenties naar instanties van een bepaalde klasse. elk element heeft twee indexen de beide indexen beginnen op nul.

SCHEMATISCHE VOORSTELLING VAN EEN 3 x 4 ARRAY Kolom 0 Kolom 1 Kolom 2 Kolom 3 Rij 0 a[ 0 ][ 0 ] a[ 1 ][ 0 ] a[ 2 ][ 0 ] a[ 0 ][ 1 ] a[ 1 ][ 1 ] a[ 2 ][ 1 ] a[ 0 ][ 2 ] a[ 1 ][ 2 ] a[ 2 ][ 2 ] a[ 0 ][ 3 ] a[ 1 ][ 3 ] a[ 2 ][ 3 ] Rij 1 Rij 2 index index naam van de array Fig. 7.14 A double-subscripted array with three rows and four columns.

TWEE-DIMENSIONALE ARRAY DECLAREREN EN INITIALISEREN Een twee-dimensionale array declareren en initialiseren b[2][2] int b[][] = { { 1, 2 }, { 3, 4 } }; rij 0 1 2 rij 1 3 4 kolom 0 kolom 1 b[0][0] bevat de waarde 1, b[0][1] bevat de waarde 2 b[1][0] bevat de waarde 3, b[1][1] bevat de waarde 4

int b[][] = { { 1, 2 }, { 3, 4 } }; De naam van de array is b. De array b heeft 4 elementen. Met behulp van de naam van de array en de twee indexen krijgt elk element zijn eigen naam, in ons voorbeeld b[0][0], b[0][1], b[1][0] en b[1][1].

TWEE-DIMENSIONALE ARRAY DECLAREREN EN INITIALISEREN Ander voorbeeld: int b[][] = { { 1, 2 }, { 3, 4, 5 } }; rij 0 1 2 rij 1 3 4 5 kolom 0 kolom 1 kolom 2 b[0][0] bevat de waarde 1, b[0][1] bevat de waarde 2 b[1][0] bevat de waarde 3, b[1][1] bevat de waarde 4, b[1][2] bevat de waarde 5

DECLARATIE EN CREATIE voorbeeld: een 3 x 4 array declareren int b[][]; // een referentie declareren die naar // een twee-dim. array-object kan verwijzen. b = new int[ 3 ][ 4 ]; //een twee dim. array- //object creëren en er met de referentie naar verwijzen. OF de twee acties combineren: int b[][] = new int[ 3 ][ 4 ]; Elk element wordt automatisch geïnitialiseerd!

REFERENTIES int b[][]; b = new int[ 3 ][ 4 ]; OF int b[][] = new int[ 3 ][ 4 ]; b is een variabele dat naar een 2 dim. array-object verwijst. M.a.w. b is een referentie. rij 0 0 0 0 0 b 0 0 0 0 1 0 0 0 0 2 kolom 0 1 2 3

DECLARATIE EN CREATIE ander voorbeeld: int b[][]; b = new int[ 2 ][ ]; // 2 rijen b[ 0 ] = new int[ 5 ]; // rij 0 heeft 5 kolommen b[ 1 ] = new int[ 3 ]; // rij 1 heeft 3 kolommen rij 0 0 0 0 0 0 b 0 0 0 1 kolom 0 1 2 3 4

VOORBEELD 1 Twee “twee-dimensionale array’s” declareren en initialiseren. De elementen van de array’s weergeven op het scherm.

1 // Fig. 7.14: InitArray.java 2 // Initialisatie van twee dimensionale arrays 3 import java.awt.Container; 4 import javax.swing.*; 5 6 public class InitArray extends JApplet 7 { 8 private JTextArea outputArea; 13 // applet initializeren 14 public void init() 15 { 16 outputArea = new JTextArea(); 17 Container container = getContentPane(); 18 container.add( outputArea ); 19 20 int array1[][] = { { 1, 2, 3 }, { 4, 5, 6 } }; 21 int array2[][] = { { 1, 2 }, { 3 }, { 4, 5, 6 } }; 22 23 outputArea.setText( "Values in array1 by row are\n" ); 24 buildOutput( array1 ); 25 26 outputArea.append( "\nValues in array2 by row are\n" ); 27 buildOutput( array2 ); 28 } creatie en initialisatie van de array’s. De arrays zijn lokale variabelen

array[row].length geeft het aantal kolommen van de rij ‘row’ terug. 30 // de elementen van de array toevoegen aan outputArea 31 public void buildOutput( int array[][] ) 32 { 33 // de rijen van de array doorlopen 34 for ( int row = 0; row < array.length; row++ ) 35 { 36 // de kolommen van een rij doorlopen 37 for ( int column = 0; 38 column < array[ row ].length; 39 column++ ) 40 outputArea.append( array[ row ][ column ] + " " ); 41 42 outputArea.append( "\n" ); 43 } 44 } 45 } Lijn 38: array[row].length geeft het aantal kolommen van de rij ‘row’ terug.

We hebben 3 studenten. Per student worden er 4 punten van examens bijgehouden  3x4 array Op het scherm wordt weergegeven: slechtste examen; beste examen; gemiddelde punten van de examens per student. VOORBEELD 2

Een twee-dimensionale array als lokale variabele declareren. … 16 // initialisatie van de instantie-variabelen 17 public void init()//verschillend van het boek 18 { 19 int grades[][] = { { 77, 68, 86, 73 }, 20 { 96, 87, 89, 81 }, 21 { 70, 90, 86, 81 } }; 22 students = grades.length; // aantal studenten 23 exams = grades[ 0 ].length; // aantal examens 24 25 // creatie JTextArea en verbinden aan applet 26 outputArea = new JTextArea(); 27 Container container = getContentPane(); 28 container.add( outputArea ); 29 30 // output string: 31 output = "The array is:\n"; 32 buildString(grades); Een twee-dimensionale array als lokale variabele declareren. Lijn 19-21: Elke rij stelt een student voor. Elke kolom stelt een punt van een examen voor. Lijn 22: grades.length geeft het aantal rijen terug. Lijn 23: grades[0].length geeft het aantal kolommen van rij 0 terug.

34 // de methodes minimum en maximum oproepen 35 output += "\n\nLowest grade: " + minimum(grades) + 36 "\nHighest grade: " + maximum(grades) + "\n"; 37 38 // per student de methode average oproepen 39 for ( int counter = 0; counter < students; counter++ ) 40 output += "\nAverage for student " + counter + " is " + 41 average( grades[ counter ] ); 42 43 // de font van outputArea wijzigen 44 outputArea.setFont( 45 new Font( "Courier", Font.PLAIN, 12 ) ); 46 47 // de output string in outputArea zetten 48 outputArea.setText( output ); 49 } //einde methode init Lijn 35-36: de methodes minimum en maximum oproepen. M.a.w. het slechtste en het beste examen bepalen. Lijn 39-41: per student de methode average oproepen. M.a.w. per student zijn gemiddelde berekenen.

51 // het slechtste examen zoeken 52 public int minimum(int grades[][]) 53 { 54 // initialisatie: eerste element is het slechtste examen 55 int lowGrade = grades[ 0 ][ 0 ]; 56 57 // de rijen van de array doorlopen 58 for ( int row = 0; row < students; row++ ) 59 60 // de kolommen per rij doorlopen 61 for ( int column = 0; column < exams; column++ ) 62 // Controleren als huidige punt van examen 63 // kleiner is dan “lowGrade” 64 // Zoja, huidig punt toekennen aan “lowGrade” 65 if ( grades[ row ][ column ] < lowGrade ) 66 lowGrade = grades[ row ][ column ]; 67 68 return lowGrade; // geeft het slechtste examen terug 69 } Lijn 58-66: geneste for-herhalingsstructuur gebruiken om het slechtste examen te bepalen.

71 // het beste examen zoeken 72 public int maximum(int grades[][]) 73 { 74 // initialisatie: eerste element is het beste examen 75 int highGrade = grades[ 0 ][ 0 ]; 76 77 // de rijen van de array doorlopen 78 for ( int row = 0; row < students; row++ ) 79 80 // de kolommen per rij doorlopen 81 for ( int column = 0; column < exams; column++ ) 82 // Controleren als huidige punt van examen 83 // groter is dan “highGrade”. 84 // Zoja, huidig punt toekennen aan “highGrade”. 85 if ( grades[ row ][ column ] > highGrade ) 86 highGrade = grades[ row ][ column ]; 87 88 return highGrade; // geeft het beste examen terug 89 } Lijn 78-86: geneste for-herhalingsstructuur gebruiken om het beste examen te bepalen.

92 // de gemiddelde punten van een student bepalen 93 public double average( int setOfGrades[] ) 94 { 95 int total = 0; // total initialiseren op nul 96 97 // som van de punten van één student 98 for ( int count = 0; count < setOfGrades.length; count++ ) 99 total += setOfGrades[ count ]; 100 101 // geeft de gemiddelde punten terug 102 return ( double ) total / setOfGrades.length; 103 } Lijn 93: de methode average heeft 1 formeel argument: een één-dimensionale array, nl. de 4 punten van één student. Lijn 102: de som van de punten (total) wordt gedeeld door het aantal punten (setOfGrades.length).

105 // output string opvullen 106 public void buildString(int grades[][]) 107 { 108 output += " "; // used to align column heads 109 110 // titel van kolommen [0] [1] [2] [3] 111 for ( int counter = 0; counter < exams; counter++ ) 112 output += "[" + counter + "] "; 113 114 // per rij: titel (grades[x]) en de overeenkomstige punten 115 for ( int row = 0; row < students; row++ ) 116 { output += "\ngrades[" + row + "] "; 117 118 for ( int column = 0; column < exams; column++ ) 119 output += grades[ row ][ column ] + " "; 120 } //einde for 121 } //einde methode buildString 122 }

Vind de fout(en) in volgende stukjes code: 1. final int MAX = 10; int table[][] = new int [MAX][MAX]; for (int i= 0; i<= table.length; i++) for (int j= 0; j<= table[j].length; j++) table[i,j] = i+ j;

Schrijf de methodes invoer en gemiddelde. Gegeven: import javax.swing.*; public class OefTheorie { public static void main(String arg[]) double gem; int table[][] = new int [3][2]; invoer(table); gem = gemiddelde(table); JOptionPane.showMessageDialog(null, "gemiddelde is " + gem); System.exit(0); } //einde methode main Schrijf de methodes invoer en gemiddelde. Methode invoer: de gebruiker geeft alle elementen van de array in. De methode “gemiddelde” berekent het gemiddelde van alle elementen van de array.