Java ArrayList: Erstellen, Hinzufügen, Entfernen, Durchlaufen und Sortieren

Eine Liste, die sich selbst in der Größe anpasst

Ein einfaches Java-Array hat eine feste Länge: Entscheidest du dich für zehn Plätze, hast du für immer zehn Plätze. ArrayList ist die größenveränderliche Alternative aus java.util - sie wächst, wenn du etwas hinzufügst, und schrumpft, wenn du etwas entfernst, und sie bringt praktische Methoden für das mit, was man tatsächlich mit einer Liste tut.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Ada");
        names.add("Boris");
        names.add("Chen");

        System.out.println(names);
        System.out.println("Count: " + names.size());
    }
}

Beachte den Typ in spitzen Klammern - List<String> - der dem Compiler mitteilt, dass diese Liste String-Werte enthält. Das <> (der „Diamond") auf der rechten Seite lässt Java denselben Typ ableiten, ohne ihn zu wiederholen. Und beachte, dass du java.util.ArrayList importierst; sie ist nicht standardmäßig verfügbar.

Als List deklarieren, als ArrayList konstruieren

Fast immer wirst du die Variable über die Schnittstelle List statt über die konkrete ArrayList deklariert sehen:

List<String> names = new ArrayList<>();

Das ist eine gute Gewohnheit, keine Regel. Gegen die Schnittstelle List zu programmieren bedeutet, dass dem Rest deines Codes egal ist, welche Listenimplementierung du verwendet hast, sodass du sie später durch eine andere ersetzen kannst, ohne ihn anzufassen. Im Alltag verhalten sich beide gleich.

Hinzufügen, Lesen und Ändern

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");      // hängt ans Ende an
        fruits.add("banana");
        fruits.add(1, "cherry");  // fügt an Index 1 ein

        System.out.println(fruits.get(0));   // liest nach Index
        fruits.set(0, "apricot");            // überschreibt Index 0

        System.out.println(fruits);
    }
}

• add(value) hängt ans Ende an.
• add(index, value) fügt an einer Position ein und verschiebt spätere Elemente nach rechts.
• get(index) liest das Element an einer Position (nullbasiert).
• set(index, value) überschreibt ein vorhandenes Element.

Indizes sind nullbasiert, und get auf einen Index außerhalb des gültigen Bereichs wirft IndexOutOfBoundsException.

Elemente entfernen

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");

        fruits.remove("banana");  // entfernt nach Wert (erster Treffer)
        fruits.remove(0);         // entfernt nach Index

        System.out.println(fruits);
    }
}

Es gibt eine klassische Falle, wenn die Liste Integer enthält. remove(int) bedeutet „nach Index entfernen" und remove(Object) bedeutet „nach Wert entfernen", also:

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30));
nums.remove(1);                      // entfernt Index 1 -> den Wert 20
nums.remove(Integer.valueOf(20));    // entfernt den Wert 20

Verpacke den Wert in Integer.valueOf(...), wenn du „entferne diesen Wert" meinst und nicht „entferne diesen Index".

Größe, contains und Index-Suchen

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        System.out.println(fruits.size());            // 3
        System.out.println(fruits.isEmpty());         // false
        System.out.println(fruits.contains("banana")); // true
        System.out.println(fruits.indexOf("cherry"));  // 2
    }
}

List.of(...) erzeugt schnell eine unveränderliche Liste; übergibst du sie dem ArrayList-Konstruktor, erhältst du eine veränderbare Kopie, die mit diesen Werten gefüllt ist.

Eine ArrayList durchlaufen

Die sauberste Schleife ist das erweiterte for (das „for-each"):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (String fruit : fruits) {
            System.out.println(fruit.toUpperCase());
        }
    }
}

Wenn du auch den Index brauchst, nutze eine gezählte Schleife mit size() und get(i):

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (int i = 0; i < fruits.size(); i++) {
            System.out.println(i + ": " + fruits.get(i));
        }
    }
}

Eine Regel: Füge einer Liste keine Elemente hinzu und entferne keine, während eine for-each-Schleife sie durchläuft - das wirft ConcurrentModificationException. Um passende Einträge sicher zu löschen, nutze removeIf:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // entfernt die geraden Zahlen
        System.out.println(nums);
    }
}

Sortieren

Collections.sort ordnet eine Liste an Ort und Stelle nach der natürlichen Ordnung (alphabetisch bei Strings, numerisch bei Zahlen):

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(3, 1, 4, 1, 5, 9, 2, 6));

        Collections.sort(nums);
        System.out.println(nums);

        nums.sort(Collections.reverseOrder());  // absteigend
        System.out.println(nums);
    }
}

Für eigene Sortierungen übergibst du list.sort(...) einen Comparator - zum Beispiel names.sort(Comparator.comparingInt(String::length)), um nach Länge zu sortieren.

ArrayList enthält Objekte, keine primitiven Typen

Du kannst nicht ArrayList<int> schreiben. Generics funktionieren nur mit Objekttypen, nutze daher die Wrapper-Klasse Integer, Double, Boolean und so weiter:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> scores = new ArrayList<>();
        scores.add(95);   // der int 95 wird per Autoboxing zu Integer
        scores.add(88);

        int first = scores.get(0);  // wird per Auto-Unboxing wieder zu int
        System.out.println(first + scores.get(1));
    }
}

Javas Autoboxing wandelt für dich zwischen int und Integer um, sodass sich das natürlich liest - denke nur daran, dass die Liste selbst Integer-Objekte speichert.

Weiter: HashMap

ArrayList ist das richtige Werkzeug, wenn dir Reihenfolge und Position wichtig sind. Wenn du Dinge über einen Schlüssel nachschlagen musst - einen Benutzernamen zu einem Benutzer, einen Produktcode zu einem Preis - willst du eine HashMap, die auf der nächsten Seite kommt.