Programmeren in Java/Arrays

Je zult het misschien al meegemaakt hebben dat je veel variabelen declareerd en gebruikt die gelijkaardige informatie bevatten en eigenlijk bij elkaar horen. Je hebt dan misschien het volgende gedaan:

String name1 = "Karen";
String name2 = "Klaas";
String name3 = "Tom";
String name4 = "Joke";
String name5 = "Linda";

// Uitprinten van de namen.
System.out.println(name1);
System.out.println(name2);
System.out.println(name3);
System.out.println(name4);
System.out.println(name5);

Dit heeft als probleem dat je dezelfde code telkens moet herhalen. Je moet telkens een regel code schrijven voor een nieuwe variabele die een bepaalde naam bevat, om vervolgens een regel code te schrijven om de naam uit te printen. Als je meer namen moet bewaren en uitprinten, moet je telkens keer meer code schrijven. Naast het feit dat dit tijdrovend is met veel manueel werk, vergroot ook de kans op fouten. Gelukkig kunnen arrays helpen om gegevens te groeperen die bij elkaar horen.

Een array aanmaken

Een array aanmaken en gegevens invoegen in Java gebeurt in drie stappen:

• De eerste stap is het declareren van een array. Net zoals bij variabelen geeft je aan welk datatype de array heeft en welke naam.
• De array initializeren is de array effectief aanmaken en koppelen aan de naam die we eerder hadden gedeclareerd.
• Vervolgens kunnen we gegevens in de array plaatsen.

Laten we beginnen met de eerste stap, de array declareren. Dit doe je net zoals bij gewone variabelen door een datatype te vermelden en een naam. Je moet daar dan ook nog vierkante haakjes aan toevoegen([]), die zullen aanduiden dat het om een array gaat. Bijvoorbeeld als volgt:

String[] names;

// of 

String names[];

Er wordt een voorkeur gegeven om de haakjes bij het datatype te plaatsen en niet bij de naam van de array, dus String[].

Vervolgens moeten we de array initializeren, dit kunnen we doen met het sleutelwoord new zoals hieronder:

String[] names = new String[5];

Zoals je ziet moeten we nogmaals het datatype vermelden als ook de haakjes met een getal in. Het getal geeft aan hoeveel plaatsen we reserveren voor Strings, hier hebben we vijf plaatsen gereserveerd voor vijf Strings. Je bent verplicht om op voorhand te vermelden hoeveel plaatsen je in je array wilt. Dit omdat zodra de array aangemaakt is kun je het aantal plaatsen niet meer veranderen.

Je bent niet verplicht om een array te declareren en te initialiseren in één regel. Je kunt het perfect op twee regels doen.

String[] names;
// eventueel nog andere code.
names = new String[5];

Er wordt echter sterk aangeraden om dit op één regel te doen om verwarring te vermijden, doe het enkel op meerdere regels als het niet anders kan. Het spreekt trouwens voor zich dat je String kunt veranderen door eendert welk datatype je nodig hebt.

int[] integers = new int[5];
float[] floats = new float[5];
double[] doubles = new double[5];
boolean[] booleans = new boolean[5];
char[] chars = new char[5];
// enzoverder...

Gegevens plaatsen en ophalen

Een array is dus een sequentiële lijst van gegevens die bij elkaar horen, dus zoals bijvoorbeeld een array van namen. Om gegevens te plaatsen of op te halen moet je daarom verwijzen naar hun index, ofwel het volgnummer in de lijst. We willen nu aan onze array namen toevoegen. We willen de namen Karen, Klaas, Tom, Joke en Linda respectievelijk op de eerste, tweede, derde, vierde en vijfde plaats.

array

index	naam
0	Karen
1	Klaas
2	Tom
3	Joke
4	Linda

Je zult misschien gemerkt hebben dat de index met nul start, dit is géén fout. Indexen beginnen inderdaad met nul bij arrays in Java. Nu we dit weten kunnen we gegevens plaatsen in de array.

String[] names = new String[5];
names[0] = "Karen";
names[1] = "Klaas";
names[2] = "Tom";
names[3] = "Joke";
names[4] = "Linda";

Nu zul je merken dat je één regel meer hebt dan dat je oorspronkelijk had toen je de namen in aparte variabelen stopte en dat is juist wat we niet wilden. Je kunt gelukkig de gegevens in één keer plaatsen op dezelfde regel waar je de array hebt gedeclareerd en geïnitialiseerd.

// Merk op dat er geen lengte is aangegeven tussen de haakjes.
String[] names = new String[]{"Karen", "Klaas", "Tom", "Joke", "Linda"};

Of nog korter.

String[] names = {"Karen", "Klaas", "Tom", "Joke", "Linda"};

Om gegevens uit de array te halen, moet je in de omgekeerde richting werken.

String[] names = {"Karen", "Klaas", "Tom", "Joke", "Linda"};

String name = names[0];

System.out.println(name); // Geeft als output Karen.

Je kunt dus gegevens ophalen met de indexnummer, dan kun je met de gegevens iets doen zoals kopieren naar een variabele om uit te printen maar je kunt ook gewoon rechtstreeks uitprinten.

System.out.println(names[0]); // Geeft als output Karen.

Let wel, als je de gegevens ophaalt, worden ze niet verwijderd uit de array. Als je de gegevens ook wilt verwijderen met je ze overschrijven door andere informatie. Nu dat we weten hoe we gegevens er terug uithalen kunnen we hat volgende doen om al de namen te printen.

String[] names = {"Karen", "Klaas", "Tom", "Joke", "Linda"};

System.out.println(names[0]);
System.out.println(names[1]);
System.out.println(names[2]);
System.out.println(names[3]);
System.out.println(names[4]);

Nu hebben we nog steeds vijf regels om de vijf namen te printen, wat geen verbetering is. Wat we nodig hebben is een manier om de code voor het printen te hergebruiken en herhalen om de namen één voor één te printen. Dit is waar een lus goed van pas kan komen.

Een array benaderen met een lus

Met de gewone for-lus

Een element van een array één voor één ophalen doe je het best met een lus in de plaats van voor ieder element aparte code te schrijven. Je gebruikt het best een for-lus.

String[] names = {"Karen", "Klaas", "Tom", "Joke", "Linda"};

for (int i = 0; i < names.length; i++) {
    System.out.println(names[i]);
}

De variabele i zal bepalen welk element uit de array wordt gehaald. Aangezien java zero-based is moet je beginnen met 0, 0 betekent hier echter het eerste element, 1 het tweede, 2 het derde enzovoort. Nadat de for-lus één keer werd uitgevoerd zal i worden verhoogd met één en kan de volgende element worden gebruikt. Dit stukje programma toont de inhoud van de array maar je kunt op deze manier natuurlijk ook natuurlijk gegevens inlezen.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] names = new String[5];

        for (int i = 0; i < names.length; i++) {
            System.out.print("Geeft naam nummer " + (i + 1) + ":");
            names[i] = scanner.nextLine();
        }

        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }
}

Met als mogelijke output:

Geeft naam nummer 1:Karen
Geeft naam nummer 2:Klaas
Geeft naam nummer 3:Tom
Geeft naam nummer 4:Jake
Geeft naam nummer 5:Linda
Karen
Klaas
Tom
Jake
Linda

Doordat het aantal keer dat een naam gelezen en getoond wordt afhangt aan de lengte van de array kun je simpelweg de lengte van de array aanpassen om meer namen te lezen en te tonen. Zelfs als je 100 namen zou lezen heb je nog steeds hetzelfde aantal regels code.

Met de for-each-lus

Je kunt ook de for-each lus gebruiken. Er moet echter een onderscheid worden gemaakt tussen arrays van primitieve variabelen(zoals int, char, enz.) en Objecten. Het volgende stukje programmacode laat de for-each-lus werken met een array van primitieve variabelen.

int getallen[] = {1,2,3,4,5};
for(int i : getallen){
	System.out.println(i);
}

In dit voorbeeld is er een array van int's. Bij de for-lus is er een variabel genaamd i. Deze dient om tijdelijk de getallen van de array in te lezen. Eerst wordt het eerste getallen ingelezen en in de variabele i geplaatst vervolgens wordt die getoond op het scherm. Dan wordt het tweede genomen enzoverder. Het nut is dat het meteen programmacode bespaart. Kijk maar naar het vorige stukje code en je ziet meteen een groot verschil. Er is echter een grote maar in dit verhaal je kunt met deze for-each-lus de gegevens niet aanpassen noch nieuwe gegevens in de array plaatsen.

int getallen[] = {1,2,3,4,5};
for(int i: getallen){
	i++;
}

Dit programmacode zal geen effect hebben op het getal van de array zelf, de gegevens blijven hetzelfde hier komt echter ook meteen het onderscheid met een array van objecten. In tegenstelling met primitieve variabelen waar de inhoud wordt gekopieerd in een nieuwe variabele wordt bij een object het adres in het werkgeheugen van het object gekopieerd naar een "nieuw" object. Hierdoor kunnen er wel bewerkingen worden gedaan bij zo'n for-lus.

Een array kopiëren

Een array kopiëren naar de andere gaat niet zomaar.

String[] names = {"Karen", "Klaas", "Tom", "Joke", "Linda"};
String[] names2 = names;

Er is niets mis met deze code. Maar er is echter een groot probleem, dit volgend stukje code zal het verduidelijken.

String[] names = {"Karen", "Klaas", "Tom", "Joke", "Linda"};
String[] names2 = names;

for(int i = 0; i < names2.length; i++){
    names2[i] = names2[i].toUpperCase();
}

for(int i = 0; i < names.length; i++){
    System.out.println(names[i]);
}

Scherm:

KAREN
KLAAS
TOM
JOKE
LINDA

Als je de code hebt gelezen zul je wel snappen dat er iets niet klopt. We hebben de namen aangepast in de array names2 maar als we de array names op het scherm tonen zijn die ook aangepast. Dit komt omdat je niet de gegevens kopieert maar omdat je het adres waar de gegevens zich bevinden in het werkgeheugen kopieert. Hierdoor verwijzen de twee arrays naar dezelfde gegevens. Dit kan zijn nut hebben maar als je de gegevens werkelijk wilt kopiëren kun je het volgende doen.

String[] names = {"Karen", "Klaas", "Tom", "Joke", "Linda"};
String[] names2 = names.clone();

Ofwel zo:

String[] names = {"Karen", "Klaas", "Tom", "Joke", "Linda"};
String[] names2 = Arrays.copyOf(names, names.length);

De eerste manier is via .clone(). .clone() is een methode van array's en kan ook worden gebruikt bij andere objecten. Hierbij wordt een exacte kopie gemaakt van de array names en wordt het adres van de kopie gekopierd in de array names2.

De tweede manier is via Arrays.copyOf(). Hierbij wordt niet alleen de array gekopiëerd maar kun je ook bepalen hoelang de nieuwe array moet zijn. Hierdoor kun je bijvoorbeeld een extra plaats toevoegen voor een extra element toe te voegen.