Wie erstelle ich ein generisches Array in Java? Vollständige Analyse mit Beispielen

„Generic array creation“ – ein Fehler, der jeden Java-Entwickler nervt

Haben Sie jemals so etwas wie new T[10] geschrieben und als Antwort eine rote Welle vom Compiler bekommen? Wenn ja, sind Sie nicht allein. Die Frage „How can I create a generic array in Java?“ auf Stack Overflow hat Hunderttausende von Aufrufen. Und das ist kein Zufall: Das Erstellen eines generischen Arrays in Java ist eines der Themen, bei denen Theorie und Praxis auseinandergehen und die IDE sich weigert zu verstehen, was Sie von ihr wollen.

In diesem Artikel werden wir analysieren, warum Java generische Arrays verbietet, wie man die Einschränkung ohne Verlust der Typsicherheit umgeht und wann ein Array trotzdem besser ist als ArrayList. Los geht‘s!

Warum funktioniert new T[10] nicht? Die Wurzel des Übels – Type Erasure

Um zu verstehen, wie man ein generisches Array in Java erstellt, muss man zunächst begreifen, warum der Compiler schreit. Der Grund ist Type Erasure (das Löschen von Typen). Java-Generics existieren nur während der Kompilierung. Zur Laufzeit werden die Typinformationen von T gelöscht und durch Object (oder eine Grenze, falls angegeben) ersetzt.

Arrays in Java hingegen sind reifiable Typen. Sie kennen ihren Komponententyp zur Laufzeit. Daher kann die JVM überprüfen, ob Sie nur Elemente des korrekten Typs in das Array legen. Wenn Sie new T[10] schreiben könnten, wäre das Array zur Laufzeit ein Object[], und Sie könnten gleichzeitig String, Integer und Date hineinlegen – was die gesamte Idee der Typsicherheit verletzt.

Aus diesem Grund gibt der Compiler einen Fehler aus:

// ❌ Kompilierungsfehler: generic array creation\npublic class Box<T> {\n    private T[] array = new T[10];  // Cannot create a generic array of T\n}

Methode 1: Die einfachste – verwenden Sie ArrayList

Meistens brauchen Sie gar kein Array. ArrayList arbeitet intern mit Object[], bietet aber eine typsichere Schnittstelle. Dies ist die ideale Lösung, wenn Sie nicht auf Nanosekunden-Leistung fixiert sind.

import java.util.ArrayList;\nimport java.util.List;\n\npublic class GenericListExample<T> {\n    private List<T> list = new ArrayList<>();\n\n    public void add(T item) {\n        list.add(item);\n    }\n\n    public T get(int index) {\n        return list.get(index);\n    }\n\n    public int size() {\n        return list.size();\n    }\n}

Vorteile: vollständige Typsicherheit, keine Warnungen, Unterstützung für dynamische Erweiterung.
\nNachteile: geringer Overhead durch Boxing/Unboxing von Primitiven (für 99% der Anwendungen jedoch unbemerkt).

Methode 2: Der klassische Hack mit (T[]) new Object[size]

Wenn Sie wirklich ein Array benötigen (z. B. aus Leistungsgründen oder zur Kompatibilität mit einer Legacy-API), können Sie eine Typumwandlung verwenden. Dies ist sicher, wenn Sie garantieren, dass das Array niemals die Grenzen Ihrer Klasse verlässt.

public class Stack<T> {\n    private T[] elements;\n    private int size = 0;\n    private static final int DEFAULT_CAPACITY = 10;\n\n    @SuppressWarnings("unchecked")\n    public Stack() {\n        elements = (T[]) new Object[DEFAULT_CAPACITY];\n    }\n\n    public void push(T item) {\n        if (size == elements.length) {\n            resize();\n        }\n        elements[size++] = item;\n    }\n\n    public T pop() {\n        if (size == 0) {\n            throw new EmptyStackException();\n        }\n        T result = elements[--size];\n        elements[size] = null;  // Hilft dem GC\n        return result;\n    }\n\n    private void resize() {\n        elements = Arrays.copyOf(elements, elements.length * 2);\n    }\n}

Wichtig: Die Annotation @SuppressWarnings("uncheck