# Hoe gebruik je Java ArrayList?

**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](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-lijst/) 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*.

```Java
import java.util.ArrayList;
```

De algemene syntaxis is:

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

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

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

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

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

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()`.

```Java
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 resulteert in:

```Java
ArrayList: [blue, red, green]
```

### Elementen verwijderen

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

```Java
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 gewijzigde ArrayList en het element dat is verwijderd:

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

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.

```Java
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:

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

### Veranderende elementen

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

```Java
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:

```Java
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.

```Java
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:

```Java
3
```

### 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](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-for-each-lus/). Bij elke iteratie van de lus wordt het betreffende element naar de console uitgevoerd.

```Java
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 weergegeven van klein naar groot:

```Java
9
17
20
54
```


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-arraylist/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-arraylist/) for AI/LLM consumption.