H12 Tabellen

Praktijk

Inleiding

Een tabel is een rij gelijksoortige gegevens in het intern geheugen van de computer. Een tabel betekent hier iets geheel anders dan een tabel in een database. Met gelijksoortig wordt bedoeld dat een tabel uit of een aantal objecten of uit waarden van hetzelfde primitieve type bestaat.

Een tabel bestaat altijd uit een van tevoren vastgesteld aantal elementen. Het aantal elementen dat maximaal in de tabel kan worden opgenomen, heet de lengte of grootte van een tabel. Een tabel begint altijd bij element 0 en eindigt bij het aantal elementen min één. Elk element wordt in de tabel aangeduid met een geheel getal. Deze wordt de index genoemd.

Een tabel wordt ook wel een reeks of rij genoemd, in het Engels array.

Het maken van een tabel

Er zijn drie stappen nodig om een tabel te maken:

• Declareer de naam van de tabel, je wilt bijvoorbeeld een tabel maken waarin je salarissen opslaat. Omdat salarissen decimaal zijn maken we een tabel met waarden van het primitieve type double. Je kunt dit op twee manieren doen: door rechte haken achter het type te zetten of achter de naam van de variabele.

  					
  double[] salaris;
  double salaris[];
  

• Vervolgens maken we het object aan. Daarbij moet je aangeven hoe groot de tabel wordt.

  					
  salaris = new double[5]
  

• Vervolgens moet de tabel gevuld worden met waarden. Dit doe je als volgt:

  					
  salaris[0] = 100;
  salaris[1] = 200;
  salaris[2] = 300;
  salaris[3] = 400;
  salaris[4] = 500;
  

De tabel bestaat nu uit vijf elementen van het type double. Het eerste element wordt niet met 1 aangeduid maar met 0. Het laatste niet met 5 maar met 4 (= aantal - 1).

Een tabel kan heel makkelijk met het For-statement benaderd worden. Het volgende codefragment laat zien hoe je de tabel met een for-lus zou kunnen vullen in plaats van alle waardes afzonderlijk in te typen zoals hiervoor werd gedaan:

					
for (int teller = 0; teller < 5; teller ++)
    salaris[teller] = 100 * (teller + 1);

De teller teller begint bij 0 en de lus eindigt als de waarde in teller is opgelopen tot 5. Nog mooier is het Java de hoogste grens te laten bepalen:

					
for (int teller = 0; teller < salaris.length; teller ++)
    salaris[teller] = 100 * (teller + 1);

Nu hoeven we niet meer te weten hoe groot de tabel is.

Met de for-lus kan de tabel gemakkelijk op het scherm gezet worden:

					
for (int teller = 0; teller < salaris.length; teller ++)
    g.drawString("" + salaris[teller], 50, 20 * teller + 20);

het gehele programma ziet er als volgt uit:

//Voorbeeld 12.1

import java.awt.*;
import java.applet.*;

public class Tabel extends Applet {
    double salaris[];
	
    public void init() {
        salaris = new double [5];
		
        for (int teller = 0; teller < salaris.length; teller ++) {
            salaris[teller] = 100 * teller + 100;
        }
    }

    public void paint(Graphics g) {
        for (int teller = 0; teller < salaris.length; teller ++) {
            g.drawString("" + salaris[teller], 50, 20 * teller + 20);
        }
    }
}

Het maken van een kopie

Soms moeten de waarden worden gekopieerd van de éne naar een andere tabel. Je zou daarbij de volgende regel kunnen gebruiken:
kopie = salaris

Als vervolgens de elementen van kopie op het scherm wordt gezet, dan lijkt het alsof er een kopie van is gemaakt. Dat is niet waar: Er is een referentie gemaakt.

Dit wordt een ondiepe kopie (shallow copy) genoemd. Wijzigingen die op kopie plaatsvinden, worden dus tevens voor salaris doorgevoerd.

Met een for-lus kunnen we een zogenaamde diepe kopie (deep copy) maken:

for(int teller = 0; teller < salaris.length; teller ++) {
    kopie[teller] = salaris[teller];
}

Als we nu een wijziging aanbrengen in de table kopie dan blijft de table salaris ongewijzigd:

De volgende programma's laten dit principe zien:

//Voorbeeld 12.2

import java.awt.*;
import java.applet.*;

public class Tabel extends Applet  {
    double[] salaris;
    double[] kopie;
	
    public void init() {
        salaris = new double[5];
        kopie = new double[5];

        for (int teller = 0; teller < salaris.length; teller ++) {
            salaris[teller] = 100 * teller + 100;
        }
        kopie = salaris;
        kopie[3] = 1000;  //salaris[3] wordt nu ook gewijzigd!
    }

    public void paint(Graphics g) {
        for (int teller = 0; teller < salaris.length; teller ++) {
            g.drawString("" + kopie[teller], 50, 20 * teller + 20);
            g.drawString("" + salaris[teller], 100, 20 * teller + 20);
        }
    }
}

//Voorbeeld 12.3

import java.awt.*;
import java.applet.*;

public class Tabel extends Applet  {
    double[] salaris;
    double[] kopie;
	
    public void init() {
        salaris = new double[5];
        kopie = new double[5];

        for (int teller = 0; teller < salaris.length; teller ++) {
            salaris[teller] = 100 * teller + 100;
        }
         for (int teller = 0; teller < salaris.length; teller ++) {
             kopie[teller] = salaris[teller]
         }
        kopie[3] = 1000;  //salaris[3] wordt nu niet gewijzigd!
    }

    public void paint(Graphics g) {
        for (int teller = 0; teller < salaris.length; teller ++) {
            g.drawString("" + kopie[teller], 50, 20 * teller + 20);
            g.drawString("" + salaris[teller], 100, 20 * teller + 20);
        }
    }
}

Test beide applets. In voorbeeld 12.2 is de waarde in het vierde element in beide tabellen 1000 geworden, in voorbeeld 12.3 is alleen in kopie de waarde van het vierde element 1000 geworden.

Een tabel initialiseren

Een tabel initialiseren betekent dat de beginwaarden in een tabel gezet worden. Dat gaat het snelst op de volgende manier:

double[] salaris = { 100, 200, 300, 400, 500 };

Dat is alleen maar mogelijk als van tevoren bekend is, wat de beginwaarden van een tabel moeten zijn. Als de beginwaarden niet bekend zijn, kun je de tabel standaard-beginwaarden meegeven, bijvoorbeeld een nul.

Grootste waarde in een tabel

Soms moet de grootste of de kleinste waarde in een tabel gezocht worden. Dat kun je doen door de tabel met een for-lus te doorlopen. In onderstaand voorbeeld is de eerste waarde de grootste die tot dan toe is waargenomen. Die waarde zetten we in de variabele waarin we de grootste bewaren. Als in de lus een grotere waarde wordt gevonden, dan zetten we die in de variabele:

//Voorbeeld 12.4

import java.awt.*;
import java.applet.*;

public class Tabel extends Applet {
    double[] salaris = { 100.0, 200.0, 500.0, 400.0, 300.0 }; 
    double maximum;
    
    public void init() {
        maximum = salaris[0];
        for (int teller = 0; teller < salaris.length; teller ++) {
            if(salaris[teller] > maximum) {
                maximum = salaris[teller];
            }
        }
    }

    public void paint(Graphics g)  {
        g.drawString("Het maximum is: " + maximum, 50, 20);
    }
}
    

Wanneer je de kleinste wilt zoeken hoef je alleen het groter-dan (>) teken te vervangen met kleiner-dan (<)

Zoeken in een tabel

Het zoeken in een tabel gaat op een vergelijkbare wijze. Je begint bij het eerste element en je zoekt totdat de waarde die je zocht is gevonden of tot het einde van de tabel. Om te kunnen weten, of een waarde is gevonden, maken we een hulpvariabele van het type boolean. Deze heeft maar twee mogelijke waarden: waar of niet waar (true / false).

//Voorbeeld 12.5

import java.awt.*;
import java.applet.*;

public class Tabel extends Applet {
    boolean gevonden;
    double[] salaris = { 100.0, 200.0, 500.0, 400.0, 300.0 }; 
    double gezocht;
	
    public void init() {
        gezocht = 400;
        gevonden = false;
        int teller = 0;
        while(teller < salaris.length) {
            if(salaris[teller] == gezocht) {
                gevonden = true;
            }
            teller ++;
        }
    }

    public void paint(Graphics g) {
        if(gevonden == true) {
            g.drawString("De waarde is gevonden.", 20, 50);
        }
        else {
            g.drawString("De waarde is niet gevonden.", 20, 50);
        }
    }
}

Voorbeeld 12.5 heeft één nadeel. Als de gezochte waarde gevonden is, gaat de lus door met zoeken terwijl dat niet nodig is. Bij vijf elementen is dat niet erg, er is nauwelijks tijdverlies, maar bij een tabel van 100.000 elementen kan dat - zeker bij een ingewikkelde zoekopdracht - tijdrovend zijn. Er moet aan dit programma nog iets toegevoegd worden waardoor de lus stopt als de gezochte waarde is gevonden.

Sorteren

Sorteren is tegenwoordig niet meer moeilijk in Java. De klasse Arrays heeft een methode sort, waarmee gemakkelijk een tabel gesorteerd kan worden. Wel moet de package "util" geïmporteerd worden:

//Voorbeeld 12.6

import java.awt.*;
import java.applet.*;
import java.util.*;

public class Stringarrays extends Applet {
    String[] namen = { "Valerie", "Jeroen", "Sander", "Frank"}; 
	
    public void init() {
        Arrays.sort(namen);
    }

    public void paint(Graphics g) {
        for (int teller = 0; teller < namen.length; teller ++) {
            g.drawString("" + namen[teller], 50, 20 * teller + 20);
        }
    }
}

Tot slot

Behalve in het laatste voorbeeld zijn tot nu alleen doubles gebruikt voor tabellen, maar ook van bijvoorbeeld tekstvakken en van strings zijn op dezelfde manier tabellen te maken. In voorbeeld 12.6 zag je hoe een array van strings gemaakt kan worden.