ArrayList is een van de meest gebruikte datastructuren in Java. Hiermee kunt u een verzameling objecten dynamisch wijzigen en opslaan. In deze tutorial laten we u kennismaken met de syntaxis van Java ArrayList en leggen we uit wanneer u deze kunt gebruiken.

Wat is het verschil tussen ArrayList en Array in Java?

Java ArrayList is dynamisch, wat betekent dat het in omvang toeneemt en afneemt wanneer elementen worden toegevoegd of verwijderd. Het is vermeldenswaard dat de ArrayList-klasse deel uitmaakt van het Java Collections Framework en niet standaard beschikbaar is. In tegenstelling tot arrays moet deze worden geïmporteerd uit de java.util-bibliotheek.

ArrayLists zijn een geschikte keuze wanneer de lengte van een Java List mogelijk kan variëren. Voorbeelden hiervan zijn het opslaan van objecten, het zoeken of sorteren van gegevens en het maken van lijsten of wachtrijen.

Het is daarentegen niet mogelijk om de grootte van een array te wijzigen. Dit betekent dat u idealiter van tevoren moet weten hoeveel objecten de array zal bevatten. Arrays zijn geschikt voor het beheren van een vooraf gedefinieerde set primitieve gegevenstypen, zoals int, float, char of Boolean.

Een nadeel van ArrayLists is dat het langer kan duren om ze te openen. Terwijl arrays een vast, aaneengesloten blok geheugen hebben, worden objecten in ArrayLists niet aaneengesloten opgeslagen. Het is belangrijk om rekening te houden met de voor- en nadelen van de datastructuren, zodat u degene kunt kiezen die het beste bij uw gebruikssituatie past.

Wat is de syntaxis voor Java ArrayList?

Voordat ArrayList wordt aangemaakt, moet de bijbehorende klasse worden geïmporteerd uit de java.util-bibliotheek.

import java.util.ArrayList;
Java

De algemene syntaxis is:

ArrayList<Type> arrayList= new ArrayList<>();
Java

‘Type’ staat voor het betreffende gegevenstype in Java ArrayList.

De volgende stap is het maken van lijsten van strings en integers.

ArrayList<String> arrayList= new ArrayList<>();
Java
ArrayList<Integer> arrayList= new ArrayList<>();
Java

ArrayLists gebruiken de bijbehorende wrapperklasse van primitieve gegevenstypen, zodat ze als objecten worden behandeld. Dit betekent dat u integer moet specificeren in plaats van int.

Voorbeelden van Java ArrayList-methoden

Bewerkingen zoals het toevoegen of verwijderen van elementen worden niet uitgevoerd op ArrayLists met Java-operatoren, maar via vooraf gedefinieerde methoden. Hieronder tonen we u de meest voorkomende ArrayList-methoden.

Elementen toevoegen

Nadat we de ArrayList ‘colours’ (String type) hebben aangemaakt, voegen we verschillende elementen toe met behulp van de .add().

import java.util.ArrayList;
class Main {
    public static void main(String[] args){
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println("ArrayList: " + colours);
    }
}
Java

Dit resulteert in:

ArrayList: [blue, red, green]
Java

Elementen verwijderen

Om objecten uit Java ArrayList te verwijderen, gebruiken we de .remove() methode en specificeren we de index van het element.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println("ArrayList: " + colours);
        String colour = colours.remove(1);
        System.out.println("ArrayList: " + colours);
        System.out.println("Removed Element: " + colour);
    }
}
Java

De uitvoer toont de gewijzigde ArrayList en het element dat is verwijderd:

ArrayList: [blue, green]
Removed Element: red
Java

Zoals bij de meeste programmeertalen begint het tellen in Java bij 0. Dit betekent dat het verwijderde element op index 1 red is.

Toegang tot elementen in Java ArrayList

Met behulp van de functie .get() kunnen we een element op een specifieke positie openen.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> clothes = new ArrayList<>();
        clothes.add("jacket");
        clothes.add("shirt");
        clothes.add("pullover");
        System.out.println("ArrayList: " + clothes);
        String str = clothes.get(2);
        System.out.print("Element at index 2: " + str);
    }
}
Java

Als uitvoer krijgen we:

ArrayList: [jacket, shirt, pullover]
Element at index 2: pullover
Java

Veranderende elementen

Met .set() kunnen we een element wijzigen door een nieuw element toe te wijzen aan een specifieke index.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println("ArrayList: " + colours);
        colours.set(2, "yellow");
        System.out.println("Modified ArrayList: " + colours);
    }
}
Java

We zien nu yellow in plaats van green bij index 2:

ArrayList: [blue, red, green]
Modified ArrayList: [blue, red, yellow]
Java

De lengte van Java ArrayList bepalen

Het aantal elementen in ArrayList kan eenvoudig worden berekend met behulp van de .size() -methode.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println(colours.size());
    }
}
Java

Dit is het resultaat:

3
Java

Sorteren en doorlopen van ArrayList

Om Java ArrayList te sorteren, moet de collectieklasse worden geïmporteerd. Voor de iteratie gebruiken we een Java for-each-lus. Bij elke iteratie van de lus wordt het betreffende element naar de console uitgevoerd.

import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> ages = new ArrayList<Integer>();
        ages.add(20);
        ages.add(54);
        ages.add(17);
        ages.add(9);
        Collections.sort(ages);
        for (int i : ages) {
            System.out.println(i);
        }
    }
}
Java

De elementen van ArrayList worden weergegeven van klein naar groot:

9
17
20
54
Java
Ga naar hoofdmenu