Java ArrayList: Wie Sie eine Liste erstellen und verwenden

Die ArrayList ist eine der am häu­figs­ten ver­wen­de­ten Da­ten­struk­tu­ren in Java. Sie er­mög­licht die dy­na­mi­sche Änderung und Spei­che­rung von einer Sammlung von Objekten. In diesem Tutorial stellen wir Ihnen die Syntax und Methoden der Java ArrayList vor.

Was ist der Un­ter­schied zwischen ArrayList und Array in Java?

Die Java ArrayList besitzt eine dy­na­mi­sche Größe, was bedeutet, dass Elemente einfach hin­zu­ge­fügt oder entfernt werden können. Des Weiteren gehört die ArrayList-Klasse zum Java Coll­ec­tions Framework und steht im Gegensatz zu Arrays nicht nativ zur Verfügung. Sie muss aus der Bi­blio­thek java.util im­por­tiert werden.

Ar­ray­Lists sind eine passende Wahl, wenn die Länge der Java List variieren kann. Beispiele hierfür sind das Speichern von Objekten, das Durch­su­chen oder Sortieren von Daten sowie das Erstellen von Listen oder War­te­schlan­gen.

Im Vergleich dazu ist die Größe beim Datentyp Array nicht ver­än­der­bar. Daher muss die Anzahl der Objekte, die der Array aufnehmen soll, schon vorher bekannt sein. Arrays eignen sich deshalb zum Verwalten einer vor­de­fi­nier­ten Menge von pri­mi­ti­ven Da­ten­ty­pen wie int, float, char oder boolean.

Ein Nachteil von Ar­ray­Lists ist die längere Zu­griffs­zeit. Während bei Arrays ein fest re­ser­vier­ter Spei­cher­be­reich vorliegt, ist dieser bei Ar­ray­Lists nicht zu­sam­men­hän­gend. Es ist deshalb wichtig, die je­wei­li­gen Vor- und Nachteile zu be­rück­sich­ti­gen und die richtige Da­ten­struk­tur für den je­wei­li­gen An­wen­dungs­fall aus­zu­wäh­len.

Die Syntax der Java ArrayList

Vor der Er­stel­lung einer ArrayList muss die ent­spre­chen­de Klasse aus der java.util-Bi­blio­thek im­por­tiert werden.

import java.util.ArrayList;

Die all­ge­mei­ne Syntax lautet:

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

„Type“ steht hierbei für den je­wei­li­gen Datentyp der Java ArrayList.

Nach­fol­gend erstellen wir Listen vom Typ String und Integer.

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

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

Ar­ray­Lists benutzen die ent­spre­chen­de Wrapper-Klasse von pri­mi­ti­ven Da­ten­ty­pen, damit diese wie Objekte behandelt werden. Deshalb müssen wir Integer statt int angeben.

Beispiele für Java-ArrayList-Methoden

Ope­ra­tio­nen wie das Hin­zu­fü­gen oder Entfernen von Elementen werden bei Ar­ray­Lists nicht mit Java-Ope­ra­to­ren, sondern über vor­de­fi­nier­te Methoden aus­ge­führt. Im Folgenden zeigen wir Ihnen die gän­gigs­ten ArrayList-Methoden.

Hin­zu­fü­gen von Elementen

Nachdem wir die ArrayList „colors“ vom Typ String erstellt haben, fügen wir mit der Methode .add() ver­schie­de­ne Elemente hinzu.

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

Dies führt zur Ausgabe:

ArrayList: [blue, red, green]

Entfernen von Elementen

Um Objekte aus einer Java ArrayList zu entfernen, verwenden wir die Methode .remove() mit der Angabe des Indexes des Elements.

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

Die Ausgabe zeigt die mo­di­fi­zier­te ArrayList und das entfernte Element an:

ArrayList: [blue, green]
Removed Element: red

Wie bei den meisten Pro­gram­mier­spra­chen beginnt bei Java die Zählweise an der Position 0. Daher ist das entfernte Element beim Index 1 red.

Zugreifen auf Elemente in einer Java ArrayList

Mit der Funktion .get() greifen wir auf ein Element an einer be­stimm­ten Position zu.

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

In der Ausgabe erhalten wir:

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

Ändern von Elementen

Mit .set() legen wir ein neues Element bei einem spe­zi­fi­schen Index fest.

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

In der Ausgabe sehen wir beim Index 2 nun yellow statt green:

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

Länge der Java ArrayList bestimmen

Die Anzahl der Elemente einer ArrayList lässt sich einfach mit der Methode .size() berechnen.

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

Als Ergebnis erhalten wir:

3

Sortieren und Iterieren durch eine ArrayList

Um eine Java ArrayList zu sortieren, muss die Coll­ec­tions-Klasse im­por­tiert werden. Für die Iteration benutzen wir eine Java For-Each Loop. Pro Durchlauf der Schleife wird das jeweilige Element an die Konsole aus­ge­ge­ben.

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

Die Elemente der ArrayList werden in auf­stei­gen­der Rei­hen­fol­ge wie­der­ge­ge­ben:

9
17
20
54

7c52aa8b4ff195eb3a997a56e24d8c77