Introduktion
Arrays og lister er grundlæggende datastrukturer i programmering, der bruges til at gemme og organisere data. De gør det muligt at håndtere samlinger af elementer effektivt. I stedet for at oprette flere separate variabler, giver et array os mulighed for at gemme, tilgå og håndtere en samling af værdier.
Arrays
Et array er en måde at gemme flere stykker data i én variabel i stedet for at oprette mange separate variabler. Forestil dig et array som en række kasser, hvor hver kasse kan indeholde en værdi. Hvis vi fx vil gemme fem forskellige scores i et spil, kan vi bruge et array i stedet for fem forskellige variabler.
Der er forskellige elementer til at få arrays til at fungere. For at kunne arbejde med arrays skal vi vide lidt om indeks, hvordan vi deklarerer og initialisere et array og hvordan man tilgår de forskellige elementer i et array.
Indekset i et array angiver positionen af et element. Indeksering starter ved 0, hvilket betyder, at det første element har indeks 0, det andet element har indeks 1, og så videre. 
Her har værdien 82 indeks 2, mens 66 har indeks 6. For at få adgang til værdi 27 skal vi skrive array[7].
Når vi opretter et array skal vi fortælle computeren, hvilken slags data vores array skal indeholde (f.eks. tal) og navnet på arrayet.
int[] scores; // Opretter et array, der kan gemme tal og hedder 'scores'
I koden ovenover giver vi arrayet datatypen int, men vi kan også give den andre datatyper
Når vi har deklareret et array, kan vi bestemme dets størrelse (dvs. hvor mange elementer det skal kunne indeholde) eller tildele specifikke værdier med det samme.
- Med fast størrelse uden værdier:
scores = new int[5]; // Opretter et array med plads til 5 tal, men vi har endnu ikke givet det nogen værdier.
- Med værdier fra starten:
int[] scores = {20, 11, 82, 37, 41, 25, 66, 27, 81, 92}; // Opretter og tildeler værdier til de fem pladser i arrayet
For at få adgang til eller ændre værdien af et element i arrayet, bruger vi dets indeks.
int førsteScore = scores[0]; // Får fat i den første score (20)
scores[2] = 80; // Ændrer den tredje score fra 82 til 80
Eksempel: Arrays i processing
Lad os prøve at bruge et array i et simpelt program i Processing, hvor vi gemmer positioner for cirkler, som vi tegner på skærmen.
int[] cirkelPositioner = {50, 100, 150, 200, 250}; // X-positioner for fem cirkler
void setup() {
size(300, 200); // Indstiller vinduets størrelse
}
void draw() {
background(255); // Hvid baggrund
for (int i = 0; i < cirkelPositioner.length; i++) { // Løkke der går gennem alle elementer i arrayet
ellipse(cirkelPositioner[i], 100, 20, 20); // Tegner en cirkel ved hver X-position
}
}
I dette eksempel:
- Vi bruger et array til at gemme X-positionerne for fem cirkler.
- Med en for-løkke går vi gennem hver position og tegner en cirkel på den tilsvarende X-position.
Hvordan ser det ud i processing? Inden du kopiere koden ind, så prøv at forestil dig det. Evt. tegn det på et stykke papir.
Lister
En liste fungerer på mange måder som et array, men den er mere fleksibel, fordi man kan tilføje eller fjerne elementer undervejs. Hvor arrays har en fast størrelse, kan lister vokse eller skrumpe alt efter, hvor meget data vi vil gemme i dem. Dette gør lister meget praktiske, hvis vi ikke på forhånd ved, hvor mange elementer vi skal bruge.
I Processing bruger vi typen ArrayList til at oprette lister.
Ligesom ved arrays skal vi fortælle computeren, hvilken slags data vores Liste skal indeholde og navnet på Listen.
Vi starter med at oprette en ny liste og angive, hvilken type data vi vil gemme i den (f.eks. tal eller tekst).
ArrayList<Integer> scores = new ArrayList<Integer>(); // Opretter en liste, der kan gemme heltal
Syntaksen for en ArrayList ser lidt anderledes ud end for et array. I stedet for at angive typen, navnet og størrelsen i hakparenteser [], bruger vi en særlig notation med < > til at angive typen i en ArrayList. Da en ArrayList selv kan ændre størrelse, behøver vi heller ikke at angive størrelsen, når vi opretter den.
I modsætning til arrays kan vi løbende tilføje nye elementer til en liste ved hjælp af metoden .add() .
scores.add(85); // Tilføjer 85 til listen
scores.add(90); // Tilføjer 90 til listen
Hvert element i en liste har sin egen position (indeks), og vi kan tilgå elementerne på samme måde som i et array – altså ved hjælp af deres indeks.
int førsteScore = scores.get(0); // Henter den første score (85)
Vi kan også ændre værdien af et element med .set(), eller fjerne et element fra listen med .remove().
scores.set(1, 95); // Ændrer det andet element til 95
scores.remove(0); // Fjerner det første element (85)
En liste vokser eller skrumper, alt efter hvor mange elementer der tilføjes eller fjernes. Metoden .size() fortæller os, hvor mange elementer der er i listen.
int antalScores = scores.size(); // Får antallet af elementer i listen
Eksempel: Brug af Lister i Processing
Her er et eksempel, hvor vi bruger en liste til at gemme X-positionerne for cirkler, som vi tegner på skærmen. Vi kan tilføje cirkler ved at klikke med musen.
ArrayList<Integer> cirkelPositioner = new ArrayList<Integer>(); // Opretter en liste til X-positioner
void setup() {
size(300, 200); // Indstiller vinduets størrelse
}
void draw() {
background(255); // Hvid baggrund
for (int i = 0; i < cirkelPositioner.size(); i++) { // Går gennem alle elementer i listen
ellipse(cirkelPositioner.get(i), 100, 20, 20); // Tegner en cirkel ved hver X-position
}
}
void mousePressed() {
cirkelPositioner.add(mouseX); // Tilføjer en ny X-position til listen, hvor musen er klikket
}
I dette eksempel:
- Vi opretter en liste cirkelPositioner til at gemme X-positioner for cirkler.
- Hver gang vi klikker med musen, tilføjes musens X-position til listen.
- I draw() tegnes en cirkel ved hver X-position fra listen.
Fordele og ulemper
- Mindre hukommelsesforbrug: Arrays kan bruge mindre hukommelse, da de har en fast størrelse.
- Hurtig adgang: Arrays kan være hurtigere at tilgå, da dataene er fastlagte og placeret sekventielt i hukommelsen.
- Enkel syntaks: Arrays har en enkel syntaks, hvilket gør dem nemme at bruge til faste datasæt.
- Fast størrelse: Når et array er oprettet med en bestemt størrelse, kan det ikke ændres. Det betyder, at man skal kende størrelsen på forhånd.
- Mindre fleksibilitet: Det er besværligt at tilføje eller fjerne elementer i et array, da størrelsen er låst.
- Dynamisk størrelse: En ArrayList kan vokse og skrumpe efter behov, så man kan tilføje og fjerne elementer uden at skulle oprette et nyt array.
- Indbyggede metoder: ArrayList har metoder som .add(), .remove() og .get(), som gør det nemt at manipulere dataene.
- Større hukommelsesforbrug: ArrayList kan bruge lidt mere hukommelse end arrays, da de dynamisk justerer sig selv.
- Lidt langsommere adgang: ArrayList kan være en smule langsommere end arrays, da de kræver flere ressourcer for at håndtere de dynamiske ændringer.
- Array: Godt til faste datasæt med kendt størrelse.
- Lister: Bedst til variable datasæt, hvor størrelsen kan ændres undervejs.