HOOFDSTUK 7 ARRAYS 7.1.     INLEIDING Array

Presentatie over: "HOOFDSTUK 7 ARRAYS 7.1.     INLEIDING Array"— Transcript van de presentatie:

1 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.

2 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.

3 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.

4 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].

5 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 ] … …

6 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.

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

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

9

10 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 ];

11 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 ];

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.

13 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 ] ,

14 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 ];

15 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

16 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.

17 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 { public static void main( String args[] ) { // de array initïaliseren: aan elk element van de array // een speciefieke waarde toekennen int array[] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 }; 12 String output = "Subscript\tValue\n"; // elke waarde van de elementen van de array worden // in String output achteraan toegevoegd. for ( int counter = 0; counter < array.length; counter++ ) output += counter + "\t" + array[ counter ] + "\n"; 18 JTextArea outputArea = new JTextArea(); outputArea.setText( output ); 21 JOptionPane.showMessageDialog( null, outputArea, "Initializing an Array with a Declaration", JOptionPane.INFORMATION_MESSAGE ); 25 System.exit( 0 ); 27 28 } // einde main 29 30 } // einde klasse InitArray

18 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 De operator new is niet nodig.

19 array.length geeft de grootte van de array weer. Lijn 17
String output = "Subscript\tValue\n"; // elke waarde van de elementen van de array worden // in String output achteraan toegevoegd. for ( int counter = 0; counter < array.length; counter++ ) 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.

20 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

21 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 { public static void main( String args[] ) { final int ARRAY_SIZE = 10; int array[]; 11 array = new int[ ARRAY_SIZE ]; 13 // waarde berekenen voor elk element van de array for ( int counter = 0; counter < array.length; counter++ ) array[ counter ] = * counter; 17 String output = "Subscript\tValue\n"; 19 for ( int counter = 0; counter < array.length; counter++ ) output += counter + "\t" + array[ counter ] + "\n"; 22 JTextArea outputArea = new JTextArea(); outputArea.setText( output ); 25 JOptionPane.showMessageDialog( null, outputArea, "Initializing to Even Numbers from 2 to 20", JOptionPane.INFORMATION_MESSAGE ); 29 System.exit( 0 ); 31 } // einde main 33 34 } // einde klasse InitArray

22 de constante ARRAY_SIZE wordt gedeclareerd. Lijn 10
final int ARRAY_SIZE = 10; int array[]; 11 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.

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

24 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];

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

26 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 { public static void main( String args[] ) { int array[] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 }; 10 String output = "Element\tValue\tHistogram"; 12 // voor elk element, een histogram maken (rij van *) for ( int counter = 0; counter < array.length; counter++ ) { output += "\n" + counter + "\t" + array[ counter ] + "\t"; // ouput opvullen met een aantal * for ( int stars = 0; stars < array[ counter ]; stars++ ) output += "*"; 20 } // einde for 22 JTextArea outputArea = new JTextArea(); outputArea.setText( output ); 25 JOptionPane.showMessageDialog( null, outputArea, "Histogram Printing Program", JOptionPane.INFORMATION_MESSAGE ); 28 System.exit( 0 ); 30 } // einde main 32 33 } // einde klasse Histogram

27 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 { output += "\n" + counter + "\t" + array[ counter ] + "\t"; // ouput opvullen met een aantal * for ( int stars = 0; stars < array[ counter ]; stars++ ) 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 += ***

28 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

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

30 9 int frequency[] = new int[ 7 ];
11 // werp de teerling 6000 keer 12 for ( int roll = 1; roll <= 6000; roll++ ) 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.

31 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

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

33 declaratie van responses.
9 int responses[] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, , 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, , 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!!!

34 responses[0] is gelijk aan 1, dan wordt frequency[1] met één verhoogd.
16 for ( int answer = 0; answer < responses.length; answer++ ) 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

35 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.

36 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.

37 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.

38 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.

39 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

40 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

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

42 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 { // applet initialiseren public void init() { JTextArea outputArea = new JTextArea(); Container container = getContentPane(); container.add( outputArea ); 14

43 De elementen van de array initïaliseren.
int array[] = { 1, 2, 3, 4, 5 }; 16 String output = "Effects of passing entire array by reference:\n" + "The values of the original array are:\n"; 19 // de oorspronkelijke elementen van de array toevoegen aan String output for ( int counter = 0; counter < array.length; counter++ ) 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 + “ ”

44 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 { for ( int counter = 0; counter < array2.length; counter++ ) 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++ ) output += " " + array[ counter ]; Lijn 29/30 output = output + “ ”

45 35 modifyElement( array[ 3 ] );
49 // het argument met 2 vermenigvuldigen 50 public void modifyElement( int element ) 51 { 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

46 Het object werd gewijzigd: pass-by-reference
35 modifyElement( array[ 3 ] ); 36 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

47 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):

48 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:

49 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).

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

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

52 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 { // applet initialiseren public void init() { JTextArea outputArea = new JTextArea(); Container container = getContentPane(); container.add( outputArea ); 14 int array[] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 }; 16 String output = "Data items in original order\n"; // de oorspronkelijke elementen van // de array toevoegen aan String output for ( int counter = 0; counter < array.length; counter++ ) 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).

53 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++ ) 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

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

55 De methode ontvangt 3 formele parameters
// twee elementen van de array verwisselen public void swap( int array3[], int first, int second ) { int hold; // tijdelijke hulpvariabele 61 hold = array3[ first ]; array3[ first ] = array3[ second ]; array3[ second ] = hold; } 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 aan array3[second].

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

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

58 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.

59 ALGORITME VAN LINEAR SEARCH
Bv. we wensen het getal 10 te zoeken in de array 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

60 ALGORITME VAN LINEAR SEARCH
Ander vb. we wensen het getal 5 te zoeken in de array 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

61 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 implements ActionListener 8 { private JLabel enterLabel, resultLabel; private JTextField enterField, resultField; private int array[]; 12 // initialisatie van applet's GUI public void init() { array = new int[ 100 ]; 40 for ( int counter = 0; counter < array.length; counter++ ) array[ counter ] = 2 * counter; 43 } // einde methode init De array “array” wordt gecreëerd en opgevuld in de methode init.

62 Lijn 70-71: verschillend van het boek!
// het te zoeken getal aan de gebruiker vragen. Vervolgens // wordt de methode linearSearch opgeroepen. public void actionPerformed( ActionEvent actionEvent ) { // we hadden ook "enterField.getText()" kunnen gebruiken // om de inputstring op te halen String searchKey = actionEvent.getActionCommand(); 66 // De array en het te zoeken getal worden doorgegeven // aan de methode linearSearch. Het geheel getal element // zal de index van het te zoeken getal of -1 ontvangen. int element = 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.

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

64 “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 { // De elementen van de array doorlopen for ( int counter = 0; counter < array.length; counter++ ) 51 // indien het element van de array gelijk is aan het te // zoeken getal "key", return zijn index. if ( array[ counter ] == key ) return counter; 56 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.

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

66 ALGORITME VAN BINARY SEARCHING
Bv. we wensen het getal 6 te zoeken, uit een array van 10 elementen 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

67 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

68 ALGORITME VAN BINARY SEARCHING
Bv. we wensen het getal 13 te zoeken, uit een array van 10 elementen 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.

69 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 implements ActionListener { 14 private JLabel enterLabel, resultLabel; private JTextField enterField, resultField; private JTextArea output; 18 private String display = "";

70 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 // "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 // registreer deze applet als "enterField's action listener" enterField.addActionListener( this ); 38 // "JLabel" en "JTextField" klaarzetten om de resultaten weer te geven resultLabel = new JLabel( "Result" ); 41 container.add( resultLabel ); 42

71 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++ ) 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.

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

73 70 // de methode binarySearch oproepen
int element = binarySearch( array, Integer.parseInt( searchKey ) ); 73 output.setText( display ); 75 // het resultaat van de binary search weergeven if ( element != -1 ) resultField.setText( "Found value in element " + element ); else resultField.setText( "Value not found" ); 82 } // 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.

74 84 // methode binary search
85 public int binarySearch( int array2[], int key ) 86 { int low = 0; // ondergrens int high = array.length - 1; // bovengrens int middle; // midden van de grenzen 90 // zolang de ondergrens kleiner of gelijk is aan bovengrens while ( low <= high ) { // midden van de grenzen bepalen middle = ( low + high ) / 2; 96 // de elementen van de array weergeven, waarvan hun // index tussen de ondergrens en bovengrens liggen 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 ).

75 Lijn 102: het te zoeken getal “key” werd gevonden in de array
// indien te zoeken getal gelijk is aan element met index // middle, return de index «middle» if ( key == array[ middle ] ) return middle; 104 // indien te zoeken getal < array[middle], nieuw bovenrens bepalen else if ( key < array[ middle ] ) high = middle - 1; 108 // indien te zoeken getal > element met index middle // dan nieuw ondergrens bepalen else low = middle + 1; }//einde while 114 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 : array[middle] > key  high = middle – 1 Lijn : array[middle] < key  low = middle + 1

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

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

78

79 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.

80 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 A double-subscripted array with three rows and four columns.

81 TWEE-DIMENSIONALE ARRAY DECLAREREN EN INITIALISEREN
Een twee-dimensionale array declareren en initialiseren b[2][2] int b[][] = { { 1, 2 }, { 3, 4 } }; rij rij kolom 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

82 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].

83 TWEE-DIMENSIONALE ARRAY DECLAREREN EN INITIALISEREN
Ander voorbeeld: int b[][] = { { 1, 2 }, { 3, 4, 5 } }; rij rij kolom kolom 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

84 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!

85 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 b kolom

86 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 b kolom

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

88 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 { private JTextArea outputArea; // applet initializeren public void init() { outputArea = new JTextArea(); Container container = getContentPane(); container.add( outputArea ); 19 int array1[][] = { { 1, 2, 3 }, { 4, 5, 6 } }; int array2[][] = { { 1, 2 }, { 3 }, { 4, 5, 6 } }; 22 outputArea.setText( "Values in array1 by row are\n" ); buildOutput( array1 ); 25 outputArea.append( "\nValues in array2 by row are\n" ); buildOutput( array2 ); } creatie en initialisatie van de array’s. De arrays zijn lokale variabelen

89 array[row].length geeft het aantal kolommen van de rij ‘row’ terug.
// de elementen van de array toevoegen aan outputArea public void buildOutput( int array[][] ) { // de rijen van de array doorlopen for ( int row = 0; row < array.length; row++ ) { // de kolommen van een rij doorlopen for ( int column = 0; column < array[ row ].length; column++ ) outputArea.append( array[ row ][ column ] + " " ); 41 outputArea.append( "\n" ); } } 45 } Lijn 38: array[row].length geeft het aantal kolommen van de rij ‘row’ terug.

90 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

91 Een twee-dimensionale array als lokale variabele declareren.
… // initialisatie van de instantie-variabelen public void init()//verschillend van het boek { int grades[][] = { { 77, 68, 86, 73 }, { 96, 87, 89, 81 }, { 70, 90, 86, 81 } }; students = grades.length; // aantal studenten exams = grades[ 0 ].length; // aantal examens 24 // creatie JTextArea en verbinden aan applet outputArea = new JTextArea(); Container container = getContentPane(); container.add( outputArea ); 29 // output string: output = "The array is:\n"; 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.

92 34 // de methodes minimum en maximum oproepen
output += "\n\nLowest grade: " + minimum(grades) + "\nHighest grade: " + maximum(grades) + "\n"; 37 // per student de methode average oproepen for ( int counter = 0; counter < students; counter++ ) output += "\nAverage for student " + counter + " is " + average( grades[ counter ] ); 42 // de font van outputArea wijzigen outputArea.setFont( new Font( "Courier", Font.PLAIN, 12 ) ); 46 // de output string in outputArea zetten outputArea.setText( output ); } //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.

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

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

95 92 // de gemiddelde punten van een student bepalen
public double average( int setOfGrades[] ) { int total = 0; // total initialiseren op nul 96 // som van de punten van één student for ( int count = 0; count < setOfGrades.length; count++ ) total += setOfGrades[ count ]; 100 // geeft de gemiddelde punten terug return ( double ) total / setOfGrades.length; } 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).

96 105 // output string opvullen
public void buildString(int grades[][]) { output += " "; // used to align column heads 109 // titel van kolommen [0] [1] [2] [3] for ( int counter = 0; counter < exams; counter++ ) output += "[" + counter + "] "; 113 // per rij: titel (grades[x]) en de overeenkomstige punten for ( int row = 0; row < students; row++ ) { output += "\ngrades[" + row + "] "; 117 for ( int column = 0; column < exams; column++ ) output += grades[ row ][ column ] + " "; } //einde for } //einde methode buildString 122 }

97 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;

98 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.