Programmeren in Java/Arrays

Uit Wikibooks
Naar navigatie springen Naar zoeken springen

Programmeren in Java In ontwikkeling. Revisiedatum: onbekend

Inleiding Redelijk ontwikkeld. Revisiedatum: 22 augustus 2008
  1. In- & uitvoer In ontwikkeling. Revisiedatum: 24 november 2007
  2. Stringbewerkingen In ontwikkeling. Revisiedatum: 24 november 2007
  3. Arrays Nog vrijwel niets. Revisiedatum: 24 november 2007
  4. Exceptions Redelijk ontwikkeld. Revisiedatum: 24 november 2007
  5. Ingebouwde functies Nog vrijwel niets. Revisiedatum: 20 januari 2007
  6. Multithreading Nog vrijwel niets. Revisiedatum: 20 januari 2007
  7. GUI In ontwikkeling. Revisiedatum: 24 november 2007
  8. JSP: JavaServer Pages Redelijk ontwikkeld. Revisiedatum: 24 november 2007
Appendices

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 lijn code schrijven voor een nieuwe variabele die een bepaalde naam bevat, om vervolgens een lijn 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[bewerken]

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 initializeren in één lijn. Je kunt het perfect op twee rijen doen.

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

Er wordt echter sterk aangeraden om dit op één lijn te doen om verwarring te vermijden, doe het enkel op meerdere lijnen 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[bewerken]

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 lijn 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 lijn waar je de array hebt gedeclareerd en geïnitializeerd.

// 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 lijntjes 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[bewerken]

Met de gewone for-lus[bewerken]

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 lijntjes code.

Met de for-each-lus[bewerken]

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[bewerken]

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 ook de array gekopiëerd maar kun je ook bepalen hoelang de nieuwe array moet zijn.

De lengte van een array veranderen[bewerken]

Een array kan niet groter gemaakt worden, maar door de inhoud naar een andere array te kopiëren, kan dat probleem toch opgelost worden. Met de functie .length kan de lengte van de array bepaald worden.

Java-code:

int kleine[] = new int[6];
int grotere[] = new int[kleine.length+1];

//kopieer de inhoud van de kleine tabel in de grotere
System.arraycopy(kleine, 0, grotere, 0, kleine.length);

//laat de referentie kleine naar grotere wijzen
//en grotere naar null (nergens dus)
kleine = grotere;
grotere = null;


Informatie afkomstig van http://nl.wikibooks.org Wikibooks NL.
Wikibooks NL is onderdeel van de wikimediafoundation.