# Java ArrayList: Wie Sie eine Liste erstellen und verwenden

Die **ArrayList** ist eine der am häufigsten verwendeten Datenstrukturen in Java. Sie ermöglicht die dynamische Änderung und Speicherung von einer Sammlung von Objekten. In diesem Tutorial stellen wir Ihnen die Syntax und Methoden der Java ArrayList vor.

## Was ist der Unterschied zwischen ArrayList und Array in Java?

Die Java ArrayList besitzt eine dynamische Größe, was bedeutet, dass Elemente einfach hinzugefügt oder entfernt werden können. Des Weiteren gehört die ArrayList-Klasse zum **Java Collections Framework** und steht im Gegensatz zu Arrays nicht nativ zur Verfügung. Sie muss aus der Bibliothek *java.util* importiert werden.

ArrayLists sind eine passende Wahl, wenn die Länge der [Java List](https://www.ionos.at/digitalguide/websites/web-entwicklung/java-list/) variieren kann. Beispiele hierfür sind das Speichern von Objekten, das **Durchsuchen oder Sortieren** von Daten sowie das Erstellen von Listen oder Warteschlangen.

Im Vergleich dazu ist die Größe beim Datentyp Array nicht veränderbar. Daher muss die Anzahl der Objekte, die der Array aufnehmen soll, schon vorher bekannt sein. Arrays eignen sich deshalb zum Verwalten einer vordefinierten Menge von **primitiven Datentypen** wie int, float, char oder boolean.

Ein Nachteil von ArrayLists ist die **längere Zugriffszeit**. Während bei Arrays ein fest reservierter Speicherbereich vorliegt, ist dieser bei ArrayLists nicht zusammenhängend. Es ist deshalb wichtig, die jeweiligen Vor- und Nachteile zu berücksichtigen und die richtige Datenstruktur für den jeweiligen Anwendungsfall auszuwählen.

## Die Syntax der Java ArrayList

Vor der Erstellung einer ArrayList muss die entsprechende Klasse aus der *java.util*-Bibliothek importiert werden.

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

Die allgemeine Syntax lautet:

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

„Type“ steht hierbei für den jeweiligen Datentyp der Java ArrayList.

Nachfolgend erstellen wir Listen vom Typ `String` und `Integer`.

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

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

ArrayLists benutzen die entsprechende **Wrapper-Klasse** von primitiven Datentypen, damit diese wie Objekte behandelt werden. Deshalb müssen wir `Integer` statt `int` angeben.

## Beispiele für Java-ArrayList-Methoden

Operationen wie das Hinzufügen oder Entfernen von Elementen werden bei ArrayLists nicht mit [Java-Operatoren](https://www.ionos.at/digitalguide/websites/web-entwicklung/java-operator/ "Java-Operator"), sondern über **vordefinierte Methoden** ausgeführt. Im Folgenden zeigen wir Ihnen die gängigsten ArrayList-Methoden.

### Hinzufügen von Elementen

Nachdem wir die ArrayList „colors“ vom Typ `String` erstellt haben, fügen wir mit der Methode `.add()` verschiedene Elemente hinzu.

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

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

```Java
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 modifizierte ArrayList und das entfernte Element an:

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

Wie bei den meisten Programmiersprachen 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 bestimmten Position zu.

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

In der Ausgabe erhalten wir:

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

### Ändern von Elementen

Mit `.set()` legen wir ein neues Element bei einem spezifischen Index fest.

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

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

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

```Java
3
```

### Sortieren und Iterieren durch eine ArrayList

Um eine Java ArrayList zu sortieren, muss die Collections-Klasse importiert werden. Für die Iteration benutzen wir eine **[Java For-Each Loop](https://www.ionos.at/digitalguide/websites/web-entwicklung/java-for-each-loop/)**. Pro Durchlauf der Schleife wird das jeweilige Element an die Konsole ausgegeben.

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

Die Elemente der ArrayList werden in aufsteigender Reihenfolge wiedergegeben:

```Java
9
17
20
54
```


This is a markdown version of: [https://www.ionos.at/digitalguide/websites/web-entwicklung/java-arraylist/](https://www.ionos.at/digitalguide/websites/web-entwicklung/java-arraylist/) for AI/LLM consumption.