Hoofdstuk 3: Arrays en ArrayList
Inleiding
- Een datastructuur is een verzameling van gegevens die op een bepaalde manier georganiseerd is. De structuur voorziet niet alleen om de verzameling van gegevens op te slaan maar ook om operaties te doen op die gegevens.
In object geörienteerd denken, wordt een datastructuur ook genoemd als een container of container object. Dit is een object dat verwijst naar andere object.
We hebben al arrays gezien om gegevens te organiseren als een opeenvolgende rij van gegevens. We kunnen ook arrays van objecten maken. Daarnaast bestaat er ook een slimme lijst
ArrayListdie veel meer kan dan enkel de rij van objecten bijhouden.
Arrays van objecten
Een array kan niet alleen primitieve datatypes bewaren (double, int,...) maar ook objecten.
- We kunnen arrays gebruiken om gegevens van primitieve datatypes te bewaren.
int[] rij = new int[10]; //maakt een rij van 10 gehele getallen
double[] coordinaten = {0.1 -1.0 0.3 2.4};
- We kunnen ook arrays gebruiken om objecten van een klasse in te bewaren. Bijvoorbeeld, zo kunnen we een array van Cirkel objecten bewaren:
Cirkel[] cirkelRij = new Cirkel[10]; //maakt een rij waarin 10 cirkel objecten zitten
- Dit resulteert in een array waarbij elk element wijst naar een Cirkel object. Echter, deze cirkel objecten zijn nog niet gemaakt, we moeten ze nog construeren met een de constructor van de klasse
Cirkel. We moeten dus
for (int i = 0; i < cirkelRij.length; i++) {
cirkelRij[i] = new Cirkel();
}
Een array van objecten is in feite een array van verwijzingen. Je kan een verwijzing opvragen naar een element van de array door
cirkelRij[1]. Dit is een verwijzing naar een cirkel object. Je kan dan een functie aanroepen op die verwijzing door:cirkelRij[1].berekenOppervlakte(). We hebben dus twee niveau's van verwijzen:cirkelRijrefereert naar de ArrayscirkelRij[1]refereert naar een object van de klasseCirkel
Het aanmaken van een array van objecten gebeurt in het algemeen in 3 stappen
- Declaratie van de array:
Cirkel[] cirkelRij; - Constructie van het array object met
new:cirkelRij = new Cirkel[]; - Constructie van alle objecten in de array:
- Declaratie van de array:
for (int i = 0; i < cirkelRij.length; i++){
cirkelRij[i] = new Cirkel();
}
- Onderstaand voorbeeld zal de oppervlakte berkenen van een verzameling van Cirkel objecten:
Cirkel.java
public class Cirkel{
//Constante die de PI definieert
final double PI = 3.14;
//attributen
private double straal;
public Cirkel(){
this(0);
}
public Cirkel(double straal){
this(straal);
}
public double getStraal(){
return straal;
}
public double berekenOppervlakte(){
return straal*straal*PI;
}
}
TotaleOppervlakte.java
public class TotaleOppervlakte{
public static void printCirkelRij(Cirkel[] cirkelRij){
System.out.printf("%-30f%-15f\n", "Straal", "Oppervlakte");
for(int i = 0; i < cirkelRij.length; i++){
System.out.printf("%-30f%-15f\n", cirkelRij[i].getStraal(), cirkelRij[i].berekenOppervlakte());
}
System.out.println("--------------------------------------------------------");
System.out.printf("%-30f%-15f\n","De totale oppervalkte van alle cirkels is", berekenTotaleOppervlakte(cirkelRij))
}
public static void berekenTotaleOppervlakte(Cirkel[] cirkelRij){
//Initializeer som
double som = 0;
//Bepaal de oppervlaktes van elke cirkel en voeg ze to bij som
for (int i = 0; i < cirkelRij.length; i++){
som += cirkelRij[i].berekenOppervlakte();
}
return som;
}
public static void main(String[] args){
//Declareer en construeer het array object van cirkels
Cirkel[] cirkelRij = new cirkelRij[10];
//Initialiseer elk element van de rij als een cirkel met een willekeurige straal tussen 0 en 100.
for (int i = 0; i < cirkelRij.length;i++){
cirkelRij[i] = new Cirkel(Math.random()*100);
}
//Print de info over de cirkelRij
printCirkelRij(cirkelRij);
}
}
ArrayList
Een ArrayList is een slimme lijst van allemaal objecten
Hiervoor zagen we dat we een array kunnen definiëren om een lijst van objecten in te bewaren. Maar eens de array gemaakt is, is de lengte van de array vast. Java voorziet de klasse
ArrayListdie kan gebruikt worden om een onbeperkt aantal objecten in opo te slaan.Hieronder vind je enkele methodes in ArrayList.
ArrayListis gekend als een algemene klasse met dat objecten van om het even welk type kan bevatten. Je moet specifiëren van welk type de objecten zijn die in de ArrayList kunnen zitten. Zo kunnen we ook stukjes tekst in de ArrayList plaatsen als objecten van het type String.
ArrayList<String> steden = new ArrayList<String>();
- Volgend stukje code geeft aan hoe we ArrayLists kunnen gebruiken om steden te verzamelen en te organiseren.
import java.
public class TestArrayList {
public class void main(String[] args){
// Maak een ArrayList om steden te bewaren.
ArrayList<String> lijstSteden = new ArrayList<String>();
// Voeg enkele steden toe in de lijst
lijstSteden.add("Brussel");
// lijstSteden bevat nu [Brussel]
lijstSteden.add("Brugge");
// lijstSteden bevat nu [Brussel, Brugge]
lijstSteden.add("Leuven");
// lijstSteden bevat nu [Brussel, Brugge, Leuven]
lijstSteden.add("Kortrijk");
// lijstSteden bevat nu [Brussel, Brugge, Leuven, Kortrijk]
lijstSteden.add("Gent");
// lijstSteden bevat nu [Brussel, Brugge, Leuven, Kortrijk, Gent]
System.out.println("Grootte van de lijst? " + lijstSteden.size());
System.out.println("Zit Brugge in de lijst? " + lijstSteden.contains("Brugge"));
System.out.println("Zit Oostende in de lijst? " + lijstSteden.contains("Oostende"));
System.out.println("De index van Leuven in de lijst is " + lijstSteden.indexOf("Leuven"));
System.out.println("Is de lijst leeg?" + lijstSteden.isEmpty());
// Voeg een stad toe op index 2
lijstSteden.add(2, "Antwerpen");
// lijstSteden bevat nu [Brussel, Brugge, Antwerpen, Leuven, Kortrijk, Gent]
// Verwijder een stad uit de lijstSteden
String str = "Kortrijk";
lijstSteden.remove(str); // equivalent met lijstSteden.remove("Kortrijk");
// lijstSteden bevat nu [Brussel, Brugge, Antwerpen, Leuven, Gent]
// Verwijder een stad op index 1
lijstSteden.remove(1);
// lijstSteden bevat nu [Brussel, Antwerpen, Leuven, Gent]
// Toon de inhoud van de lijst
System.out.println(lijstSteden.toString());
// Toon de inhoud van de lijst in omgekeerde volgorde
for (int i = lijstSteden.size()-1; i>=0; i--){
System.out.print(lijstSteden.get(i) + " ");
}
System.out.println();
}
}
- There are some differences and similaries between Arrays and
ArrayList
| Operation | Array | ArrayList |
|---|---|---|
| Creatie van een array/ArrayList | String[] a = new String[10] |
ArrayList<String> a = new ArrayList<String>() |
| Opvragen van een element | a[index] |
a.get(index) |
| Aanpassen van een element | a[index] = "London"; |
a.set(index, "London"); |
| Opvragen van de groote | a.length |
a.size() |
| Toevoegen van een nieuw element | kan niet in array | a.add("London"); |
| Invoegen van een nieuw element | kan niet in array | a.add(index, "London"); |
| Verwijderen van een element | kan niet in array | a.remove(index); |
| Verwijderen van een element | kan niet in array | a.remove(Object); |
| Verwijderen van alle elementen | kan niet in array | a.clear(); |
- Een ArrayList kan je enkel gebruiken om objecttypes te gaan opslaan. Primitieve types kunnen niet opgeslagen worden in ArrayList (wel in Arrays). Stel dat we een ArrayList willen maken van integers dan zou je het volgende kunnen gebruiken:
ArrayList<int> lijst = new ArrayList<int>();
- Dit zal niet werken omdat de elementen van ArrayList van het object type moeten zijn. We kunnen de primitieve klasse
intniet gebruiken in ArrayList. In plaats hiervan moeten we wikkelklasseIntegergebruiken die ook eenintvoorsteld, maar dan van het Object type.
ArrayList<Integer> lijst = new ArrayList<Integer>();
- Hieronder vind je een voorbeeldprogramma die hiervan gebruik maakt. We willen getallen opvragen via gebruikersinvoer (met behulp van de
Scannerklasse) en deze opslaan in een lijst. We weten a priori niet hoeveel nummers er gevraagd worden, dus moet onze lijst daarmee rekening houden. Traditionele arrays eisen dat de grootte op voorhand vast ligt, maar bij de klasseArrayListhoeft dat niet.ArrayListkan om met een onbekende grootte, maar eist wel dat er objecttypes in de lijst worden opgeslagen. Hiervoor kunnen we dus de wikkelklasseIntegergebruiken.
Nummer.java
import java.util.ArrayList;
import java.util.Scanner;
public class Nummers{
private ArrayList<Integer> lijst;
public Nummers(){
lijst = new ArrayList<Integer>();
}
public void voerIn(){
Scanner invoer = new Scanner(System.in);
System.out.println("Voer getallen in (als je wil eindigen voer dan 0 in):");
int getal = 0;
do{
getal = invoer.nextInt();
list.add(getal); // autoboxing -> zie hoofdstuk 2
}
}
public double berekenGemiddelde(){
double som = 0.0;
for(int i = 0; i < lijst.size(); i++){
som += lijst.get(i); //autounboxing
}
return som/lijst.size();
}
}
Het is eenvoudiger om dit te implementeren via de klasse
ArrayListom twee redenen:- De grootte van een object van het type
ArrayListis flexibel, we moeten de grootte niet specifiëren. - De klasse
ArrayListheeft veel bruikbare methodes die een object kan uitvoeren.
- De grootte van een object van het type
Een ander voordeel is dat je over een lijst kan gaan via een foreach-lus. Een foreach lus vermijdt het gebruik van een controlevariabele.
for (elementType element: arrayList){
// Process the element
}
- Bijvoorbeeld kan je het gemiddelde berekenen als volgt
public double berekenGemiddelde(){
double som = 0.0;
for(int getal : lijst){
som += getal;
}
return som/lijst.size();
}
Bruikbare methodes voor ArrayList
Java voorziet methodes voor het maken van lijsten vanuit een array, voor het sorteren van een lisjt en voor het zoeken van een maximum en een minimum in de lijst
- Array naar ArrayList
String[] array = {"rood","groen","blauw"};
ArrayList<String> lijst = new ArrayList<String>(Arrays.asList(array));
// Bemerk Arrays met hoofdletter -> asList is een statische methode in die klasse
- ArrayList naar ArrayList
String[] array1 = new String[lijst.size];
lijst.toArray(array1);
- Sorteren van een lijst
Integer[] array = {3, 5, 95, 4, 15, 34, 3, 6, 5};
ArrayList<Integer> lijst = new ArrayList<Integer>(Arrays.asList(array));
java.util.Collections.sort(lijst);
System.out.println(lijst);
- Minimum en maximum in de lijst
Integer[] array = {3, 5, 95, 4, 15, 34, 3, 6, 5};
ArrayList<Integer> lijst = new ArrayList<Integer>(Arrays.asList(array));
int maximum = java.util.Collections.max(lijst);
int minimum = java.util.Collections.min(lijst);