Why does Java reject `new T[]` and `new List<String>[]`, and how do you create such arrays safely?

## Two features that don't mix To see why generic arrays are forbidden, you must understand how **arrays** and **generics** each treat type information at runtime — and that they are opposites. ### Arrays are *reified* and *covariant* - *Reified* means the type survives to runtime: a Java array object carries its real **component type** (element type) at runtime. `new String[3]` is, at runtime, genuinely a "String array". - *Covariant* means `String[]` is a subtype of `Object[]`. So this compiles: ```java Object[] arr = new String[3]; // legal — array covariance arr[0] = 42; // throws ArrayStoreException at RUNTIME ``` Because the array knows it's really a `String[]`, the JVM checks every write and throws `ArrayStoreException` if you try to store the wrong type. The array's runtime type check is the safety net. ### Generics are *erased* (non-reified) As covered for `new T()`: generic type arguments are a compile-time-only fiction. At runtime a `List<String>` and a `List<Integer>` are both just `List`. The `<String>` part is **erased** — not reified. ## Why `new T[]` and `new List<String>[]` are banned An array's safety depends on it knowing its real element type at runtime so it can run the store check. But a generic element type is erased, so the array could only check the *erased* type. Consider the forbidden code, with what would happen if it were allowed: ```java List<String>[] a = new List<String>[1]; // ILLEGAL (generic array creation) Object[] objs = a; // array covariance — legal List<Integer> li = List.of(42); objs[0] = li; // runtime check only sees 'List' -> PASSES! String s = a[0].get(0); // ClassCastException, far from the real bug ``` The array's runtime store check can only verify the *erased* type `List` — it cannot tell `List<String>` from `List<Integer>`. So a wrong-typed list slips in silently and blows up much later when read. To prevent this *heap pollution* (a generic variable referring to an object that isn't of its declared type), the compiler **forbids generic array creation** entirely: `new T[...]`, `new List<String>[...]`, `new T[]{...}` are all compile errors. (`new List<?>[]` with an *unbounded* wildcard is allowed, because `?` is reifiable enough — but you rarely want it.) ## Workaround 1: create `Object[]` and cast (the `ArrayList` trick) ```java class Stack<T> { private T[] elements; @SuppressWarnings("unchecked") Stack(int capacity) { elements = (T[]) new Object[capacity]; // unchecked cast warning } } ``` You allocate a real `Object[]` and cast it to `T[]`. The compiler emits an **unchecked-cast warning** because it can't guarantee the cast is sound. This is acceptable *only* when the array is private/encapsulated and you never expose it as a real `T[]` to the outside (otherwise a caller could trigger `ClassCastException`). This is exactly how `ArrayList`, `ArrayDeque`, etc. are implemented. Suppress the warning narrowly with `@SuppressWarnings("unchecked")` and add a comment explaining why it's safe. ## Workaround 2: `Array.newInstance` with a `Class<T>` token When you need an array whose runtime component type is *actually* `T` (e.g. to return a real `T[]`), pass a type token and build it reflectively: ```java import java.lang.reflect.Array; @SuppressWarnings("unchecked") static <T> T[] newArray(Class<T> componentType, int length) { return (T[]) Array.newInstance(componentType, length); } String[] arr = newArray(String.class, 5); // a genuine String[] ``` This produces an array with the correct reified component type, so it *can* be safely exposed (this is how `Arrays.copyOf` / `toArray(T[])` work). The cast warning remains but is genuinely safe here. ## Practical guidance - Prefer `List<T>` (and other collections) over arrays of generics — they coexist cleanly with erasure and give compile-time checks. *Effective Java* Item 28: "prefer lists to arrays." - If you must hold a generic array internally, use the `Object[]`-cast trick and keep it private. - If you must hand back a real typed array, use `Array.newInstance` with a `Class<T>`. - Beware also of `@SafeVarargs`: a generic varargs parameter (`T... args`) secretly creates a generic array and is a common heap-pollution source. ## Key takeaway Arrays need their real element type at runtime to stay safe; generics throw that type away. Letting them combine would silently poison the heap, so the compiler bans generic array creation. Recover a typed array via an `Object[]` cast (encapsulated) or `Array.newInstance` (reified), or just use a `List`.