Hoe gebruik je Java ArrayList?

ArrayList is een van de meest gebruikte da­ta­struc­tu­ren in Java. Hiermee kunt u een ver­za­me­ling objecten dynamisch wijzigen en opslaan. In deze tutorial laten we u ken­nis­ma­ken 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 toe­ge­voegd of ver­wij­derd. Het is ver­mel­dens­waard dat de ArrayList-klasse deel uitmaakt van het Java Col­lec­ti­ons Framework en niet standaard be­schik­baar is. In te­gen­stel­ling tot arrays moet deze worden ge­ïm­por­teerd uit de java.util-bi­bli­o­theek.

Ar­ray­Lists zijn een geschikte keuze wanneer de lengte van een Java List mogelijk kan variëren. Voor­beel­den hiervan zijn het opslaan van objecten, het zoeken of sorteren van gegevens en het maken van lijsten of wacht­rij­en.

Het is daar­en­te­gen 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 ge­de­fi­ni­eer­de set pri­mi­tie­ve ge­ge­vens­ty­pen, zoals int, float, char of Boolean.

Een nadeel van Ar­ray­Lists is dat het langer kan duren om ze te openen. Terwijl arrays een vast, aan­een­ge­slo­ten blok geheugen hebben, worden objecten in Ar­ray­Lists niet aan­een­ge­slo­ten op­ge­sla­gen. Het is be­lang­rijk om rekening te houden met de voor- en nadelen van de da­ta­struc­tu­ren, zodat u degene kunt kiezen die het beste bij uw ge­bruiks­si­tu­a­tie past.

Wat is de syntaxis voor Java ArrayList?

Voordat ArrayList wordt aan­ge­maakt, moet de bij­be­ho­ren­de klasse worden ge­ïm­por­teerd uit de java.util-bi­bli­o­theek.

import java.util.ArrayList;

De algemene syntaxis is:

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

‘Type’ staat voor het be­tref­fen­de ge­ge­vens­ty­pe in Java ArrayList.

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

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

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

Ar­ray­Lists gebruiken de bij­be­ho­ren­de wrap­per­klas­se van pri­mi­tie­ve ge­ge­vens­ty­pen, zodat ze als objecten worden behandeld. Dit betekent dat u integer moet spe­ci­fi­ce­ren in plaats van int.

Voor­beel­den van Java ArrayList-methoden

Be­wer­kin­gen zoals het toevoegen of ver­wij­de­ren van elementen worden niet uit­ge­voerd op Ar­ray­Lists met Java-ope­ra­to­ren, maar via vooraf ge­de­fi­ni­eer­de methoden. Hieronder tonen we u de meest voor­ko­men­de ArrayList-methoden.

Elementen toevoegen

Nadat we de ArrayList ‘colours’ (String type) hebben aan­ge­maakt, voegen we ver­schil­len­de 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);
    }
}

Dit re­sul­teert in:

ArrayList: [blue, red, green]

Elementen ver­wij­de­ren

Om objecten uit Java ArrayList te ver­wij­de­ren, gebruiken we de .remove() methode en spe­ci­fi­ce­ren 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);
    }
}

De uitvoer toont de ge­wij­zig­de ArrayList en het element dat is ver­wij­derd:

ArrayList: [blue, green]
Removed Element: red

Zoals bij de meeste pro­gram­meer­ta­len begint het tellen in Java bij 0. Dit betekent dat het ver­wij­der­de element op index 1 red is.

Toegang tot elementen in Java ArrayList

Met behulp van de functie .get() kunnen we een element op een spe­ci­fie­ke 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);
    }
}

Als uitvoer krijgen we:

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

Ver­an­de­ren­de elementen

Met .set() kunnen we een element wijzigen door een nieuw element toe te wijzen aan een spe­ci­fie­ke 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);
    }
}

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

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

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());
    }
}

Dit is het resultaat:

3

Sorteren en doorlopen van ArrayList

Om Java ArrayList te sorteren, moet de col­lec­tie­klas­se worden ge­ïm­por­teerd. Voor de iteratie gebruiken we een Java for-each-lus. Bij elke iteratie van de lus wordt het be­tref­fen­de element naar de console uit­ge­voerd.

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);
        }
    }
}

De elementen van ArrayList worden weer­ge­ge­ven van klein naar groot:

9
17
20
54