Cursus Java2 1.5: handleiding variabelen, arrays en strings

Variabelen stellen de programmeur in staat stukjes geheugen te reserveren voor gebruik in een programma. Deze stukjes geheugen geef je een naam: de variabelenaam. Je geeft ook het type op van de waarde die je in de variabele zal bewaren. De Java-compiler moet weten of je gehele getallen, kommagetallen, tekenreeksen,... zal gebruiken , van dit type hangt ook af hoeveel geheugenruimte er voor de variabele gereserveerd wordt. Het opgeven van het type van variabele en naam van variabele noemen we declaratie van de variabele.

int getal1;
short getal2, getal3;

Later in een programma kan je deze variabelen initialiseren: een waarde toekennen aan een variabele. Deze waarde kan achteraf worden gewijzigd. Declaratie en initialisatie kunnen ook in 1 regel gebeuren:

int getal1 = 2600;
short getal2, getal3;

getal2 = 50;
getal3 = 200;

Voor het werken met gehele getallen kent Java 4 types. Deze types variëren naargelang de grootte van het getal dat je wenst te bewaren.

Type	Bereik	Bytes
byte	-128 tot 127	1
short	-32768 tot 32767	2
int	-2.147.483.648 tot 2.147.483.647	4
long	-9.223.372.036.854.775.808 tot 9.223.372.036.854.775.807	8

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

public class geheel extends java.applet.Applet {
    
    public void paint(Graphics g) {
        byte zeer_klein_geheel;
        short klein_geheel;
        int geheel, octaal_getal, hex_getal;
        long groot_geheel;
		
        zeer_klein_geheel = 40;
        klein_geheel = 365;
        geheel = 40500;
        octaal_getal = 020;
        hex_getal = 0x20;
        groot_geheel = 1234567890123456789L;
        
        g.drawString("Zeer klein geheel: " +zeer_klein_geheel,20,20);
        g.drawString("Klein geheel: " +klein_geheel,20,35);
        g.drawString("Geheel: " +geheel,20,50);
        g.drawString("Octaal getal: " +octaal_getal, 20, 65); 
        g.drawString("Hexadecimaal getal: " +hex_getal, 20, 80); 
        g.drawString("Groot_geheel: " +groot_geheel, 20, 95);    
                    
                    
    }
}

Bemerk de suffix L voor variabelen van het type long.

Kommagetallen worden opgeslagen in het geheugen als floating-points: getallen met drijvende komma. In het geheugen wordt in feite als bitreeks bewaard wat de waarde van het getal is en welke de expont van het grondtal is. Deze exponent bepaalt de positie van de komma in het getal:

2.000.000 = 2 * 10⁶ = 2E6
0,00054 = 54 * 10^-5 = 2E-5

In Java is het decimaalscheidingsteken niet de komma maar het punt!

Type	Bereik	Bytes
float	1,40129846432481707e-45 tot 3,40282346638528860e+38	4
double	4,94065645841246544e-324 tot 1,79769313486231570e+308	8

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

public class komma extends java.applet.Applet {
    
    public void paint(Graphics g) {
        float waarde;
        double waarde2;
        
        waarde = 1.538F;
        waarde2 = -4.43678945674386D;
        
        g.drawString("waarde: " +waarde ,20,20);
        g.drawString("waarde2: " +waarde2 ,20,35);            
    }
}

Bemerk de suffixen F en D voor float en double
Het standaardtype is in feite double, de suffix D voor een double hoeft in feite niet.

Variabelen van het type boolean kunnen slechts twee waarden aannemen: true of false.

type	bereik
boolean	true of false

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

public class booleans extends java.applet.Applet {
    
    public void paint(Graphics g) {
        boolean waarde;
        
        waarde = true;
        
        g.drawString("waarde: " +waarde ,20,20);            
    }
}

De basisvorm van een Java-tekenliteral is een waarde die overeenkomt met de waarde in de Unicode-tekenset. Tekenliterals worden in feite opgeslagen als getallen die dienst doen als indices in de Unicode-tekenset.

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

public class tekenliteral extends java.applet.Applet {
    
    public void paint(Graphics g) {
        char letter3,letterZ,quote;
        letter3 = 67;
        letterZ = 'Z';
        quote = '\'';
        
        g.drawString("Derde letter in het alfabet: " +letter3 ,20,20);
        g.drawString("Letter Z: " +letterZ ,20,35);
        g.drawString("Enkele quote: " +quote ,20,50);
        g.drawString("Hij sprak :\"Java is leuk!\"",20,65);
    }
}

Je kent aan een tekenliteral dus ofwel een getal toe dat overeenstemt met het Unicode-teken of tussen enkele quotes (') meteen het karakter.

Er bestaan ook teken-escapecodes om speciale tekens op het scherm te brengen:

escapecode	betekenis
\'	enkel aanhalingsteken (quote)
\"	dubbel aanhalingsteken
\\	backslash
\b	backspace
\ddd	octaal teken
\f	formfeed - nieuwe pagina
\n	newline (line feed in DOS en Windows)
\r	carriage return (nieuwe regel)
\t	tabulator
\uxxxx	hexadecimaal Unicode-teken

Java is een sterk getypeerde taal (variabeletypes worden vooraf vastgelegd). Hierdoor wordt je vaak geconfronteerd met de situatie waarbij een variabele van het ene type naar het andere moet worden omgezet.

Automatische typeconversie

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

public class typeconversie1 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        byte b1 = 30;
        int i1;
        i1 = b1;
        
        g.drawString("i1: " +i1 ,20,20);
                  
    }
}

Java zal een variabele automatisch laten veranderen van type - in dit voorbeeld een byte naar integer - wanneer volgend voorwaarden voldaan zijn:

Het gegevenstype en de variabeletypen zijn compatibel
Het doeltype heeft een groter bereik dan het brontype

Expliciete typeconversie

Wanneer het doeltype een kleiner bereik heeft dan het brontype dan moet je het gegevenstype expliciet omzetten: je moet zelf aangeven dat je het type wenst te veranderen. Doe je dit niet, dan krijg je een 'possible loss of precision'-fout.

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

public class typeconversie2 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        int i1 = 30;
        byte b1;
        b1 = (byte) i1;
        
        g.drawString("b1: " +b1 ,20,20);
                  
    }
}

Eendimensionele arrays

Arrays bieden de programmeur een manier om met reeksen gegevens van hetzelfde type te werken. De elementen uit de reeks kunnen aangeduid worden met de naam van de arrray en een indexcijfer: de positie van het element in de reeks.

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


public class array1 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        double getallen[];
        getallen = new double[100];
        
        getallen[0] = 9245.57;
        getallen[3]= 133543.67;
        
        g.drawString("Getal met nr. 0 in de Array: " +getallen[0] ,20,20);
        g.drawString("Getal met nr. 3 in de Array: " +getallen[3] ,20,35);
    }
}

Het klaarmaken van de array voor gebruik is een proces in twee stappen. Eerst declareer je de array. Hier geef je aan welk type elementen de array zal bevatten. De algemene syntax hiervoor is:

1. type arraynaam[];

In een volgende stap reserveer je geheugen voor de array: je geeft aan hoeveel elementen de array kan bevatten:

2. arraynaam = new type[aantal];
Wanneer je bv. als aantal 100 opgeeft heb je 100 geheugenplaatsen genummerd van 0 tot en met 99.

Deze stappen kan je ook in één regel code plaatsen:

samen: type arraynaam[] = new type[aantal];

Wanneer je de array ook meteen wenst te initialiseren (waarden toekennen) kan je volgende syntax gebruiken:

declaratie + initialisatie: type arraynaam[] = {waarde0, waarde1,...};

Nog een voorbeeld:

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


public class array2 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        double getallen[];                 //declaratie
        getallen = new double[100];        //toewijzen geheugenruimte
        int waarden[] = new int[20];       //declaratie + toewijzen geheugenruimte
        short nogwaarden[] = {200,40,-3};  //declaratie + initialisatie
        
        getallen[0] = 9245.57;             //initialisatie
        getallen[3]= 133543.67;
        
        waarden[1] = -50;
        waarden[6] = 12;
        
        g.drawString("Getal met nr. 0 in de Array getallen: " +getallen[0] ,20,20);
        g.drawString("Getal met nr. 3 in de Array getallen: " +getallen[3] ,20,35);
        
        g.drawString("Getal met nr. 6 in de Array waarden: " +waarden[6] ,20,50);
        g.drawString("Getal met nr. 15 in de Array waarden: " +waarden[15] ,20,65);
        
        g.drawString("Getal met nr. 2 in de Array nogwaarden: " +nogwaarden[2] ,20,80);
    }
}

Hierbij is het belangrijk op te merken dat numerieke waarden die niet geïnitialiseerd zijn als standaardwaarde nul (0) hebben.
waarden[15] werd in dit voorbeeld niet door de programmeur geïnitialiseerd.

Multidimensionele arrays

Stel dat je wenst bij te houden wat de prijs en het aantal van verkochte artikels is. Je kan hiervoor twee eendimensionale arrays aanmaken: prijs en aantal. Je kan er echter ook voor opteren deze gegevens in één array te plaatsen. Dit heeft zo zijn voordelen voor latere verwerking.

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


public class array3 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        int verkopen[][] = new int[2][4];
        
        verkopen[0][0] = 50;
        verkopen[1][0] = 1;
        
        verkopen[0][1] = 40;
        verkopen[1][1] = 3;
        
        verkopen[0][2] = 15;
        verkopen[1][2] = 2;
        
        verkopen[0][3] = 150;
        verkopen[1][3] = 1;
        
        g.drawString("Prijs element nr. 1: " +verkopen[0][1] ,20,20);
        g.drawString("Prijs element nr. 3: " +verkopen[0][3] ,20,35);
        
        g.drawString("Aantal element nr. 2: " +verkopen[1][2] ,20,50);
        g.drawString("Aantal element nr. 3: " +verkopen[1][3] ,20,65);
      
    }
}

Initialisatie bij declaratie van de array:

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


public class array4 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        int verkopen[][] = {{50,40,15,150},{1,3,2,1}};
        
        g.drawString("Prijs element nr. 1: " +verkopen[0][1] ,20,20);
        g.drawString("Prijs element nr. 3: " +verkopen[0][3] ,20,35);
        
        g.drawString("Aantal element nr. 2: " +verkopen[1][2] ,20,50);
        g.drawString("Aantal element nr. 3: " +verkopen[1][3] ,20,65);
    }
}

Onregelmatige multidimensionele arrays

In feite zijn multidimensionele arrays niets anders dan arrays in arrays. Vandaar dat je niet verplicht bent volstrekt regelmatige arrays te maken: de ene array kan gerust een ander aantal elementen bevatten dan de andere.

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


public class array5 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        double waarden[][] = new double[5][];
        waarden[0] = new double[20];
        waarden[1] = new double[10];
        waarden[2] = new double[30];
        waarden[3] = new double[25];
        waarden[4] = new double[20];
        
        waarden[2][28] = 20600.77;
        
        g.drawString("Waarde: " +waarden[2][28] ,20,20);
       
    }
}

De lengte van een array opvragen

De lengte (of het aantal elementen) van een array kan je opvragen met de eigenschap length van de array. Merk op dat deze eigenschap het aantal elementen bevat en dus steeds één hoger zal zijn dan de index van het laatste element.

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


public class array6 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        double getallen[];
        double waarden[][] = new double[5][];
        
        getallen = new double[100];
        getallen[0] = 9245.57;
        getallen[3]= 133543.67;
        
        waarden[0] = new double[20];
        waarden[1] = new double[10];
        waarden[2] = new double[30];
        waarden[3] = new double[25];
        waarden[4] = new double[20];
        
        waarden[2][28] = 20600.77;
        g.drawString("Getal met nr. 0 in de Array: " +getallen[0] ,20,20);
        g.drawString("Getal met nr. 3 in de Array: " +getallen[3] ,20,35);
        
        g.drawString("Lengte van de array getallen: " +getallen.length ,20,50);
        g.drawString("Lengte van de array waarden: " +waarden.length ,20,65);
        g.drawString("Lengte van de array waarden[2]: " +waarden[2].length ,20,80);
    }
}

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

public class string1 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        String s1 = "Groeten van Java!";
        g.drawString(s1 ,20,20);
    }
}

In Java zijn Strings geen fundamentele gegevenstypen zoals de types die we hierboven hebben besproken. Strings worden in feite afgeleid van de klassen String en StringBuffer.

Naar het coderen toe kan je echter wel met Strings werken op de eenvoudige manier zoals je met de eerder geziene types werkt.

Het grootte voordeel aan het feit dat String-tekenreeksen in feite objecten zijn afgeleid van de klasse String of StringBuffer is dat er tal van methoden voorhanden zijn in deze klassen die het werken met Strings heel gebruiksvriendelijk maken.

De String-klasse

De String-klasse is een enorm krachtige klasse.

Enkele mogelijkheden van de klasse String worden hieronder besproken, een volledig overzicht kan je vinden op de website van Sun.

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


public class string2 extends java.applet.Applet {
    
    public void paint(Graphics g) {
        String s1 = "Mijn naam is William";
        String s2;
        String s3 = new String();
        String s4 = new String("String-objecten hebben vele methodes");
        char c1[] = {'H','o','i',' ','d','a','a','r'};
        String s5 = new String(c1);
        String s6 = new String (c1,0,3);
        double d1 = 34.3476;
        String s7 = String.valueOf(d1);
        
        
        s2 = " en ik volg een cursus Java";
        s3 = " aan het IVO Brugge";
        
        
        g.drawString(s1 ,20,20);
        g.drawString(s2 ,20,35);
        g.drawString(s3 ,20,50);
        g.drawString(s4 ,20,65);
        g.drawString(s5 ,20,80);
        g.drawString(s6 ,20,95);
        g.drawString(s7 ,20,110);
        
        g.drawString("\"" +s1 +"\" is " +s1.length() +" tekens lang.",20,125);
        g.drawString(s1.concat(s2),20,140);
        g.drawString(s1.concat(s2.concat(s3)),20,155);
        g.drawString("derde teken van \"" +s1 +"\" = " +s1.charAt(2),20,170);
    }
}

methode	beschrijving
length()	Bepaalt de lengte van een tekenreeks
concat()	tekenreeksen samenvoegen
charAt()	Teken op een bepaalde positie
getChars()	opvragen van een aantal tekens en plaatsen in een char-array
subString()	opvragen van een aantal tekens, retourneert een nieuwe String
indexOf()	Doorzoeken: positie van de eerste voorkomst van een string in een andere String
lastIndexOf()	Doorzoeken: positie van de laatste voorkomst van een string in een andere String
replace()	Tekens binnen een String vervangen
split()	Splitst een tekenreeks volgens een opgegeven reguliere expressie, retourneert een array van Strings
toLowerCase()	String omzetten in kleine letters
toUpperCase()	String omzetten in hoofdletters
trim()	Voorloop- en achterloopspaties verwijderen

Meer info bij Sun.

Zowat hetzelfde als een String, maar wel een aantal andere methoden:

methode	beschrijving
append()	waarden toevoegen aan een StringBuffer
insert()	waarden invoegen in een StringBuffer
setCharAt()	Teken op een bepaalde positie instellen

Meer info bij Sun.

Java2 1.5: variabelen, arrays en strings

inleiding

Gehele getallen

Kommagetallen

Booleans

Char: tekenliterals

Converteren tussen gegevenstypen