Как создать обобщённый массив (generic array) в Java? Решение проблемы

Проблема создания обобщённого массива в Java

Вы столкнулись с классической проблемой Java: из-за стирания типов (type erasure) компилятор не может создать массив параметризованного типа T. Java просто не знает, какой тип будет подставлен во время выполнения, поэтому new T[size] запрещён на уровне компиляции.

Решение 1: Использование Array.newInstance() (рефлексия)

Самый безопасный и рекомендуемый способ — использовать рефлексию через java.lang.reflect.Array.newInstance(). Для этого нужно передать объект класса Class<T>:

public class MyContainer<T> {
    private T[] array;

    @SuppressWarnings("unchecked")
    public MyContainer(Class<T> clazz, int size) {
        array = (T[]) Array.newInstance(clazz, size);
    }

    public T get(int index) {
        return array[index];
    }

    public void set(int index, T value) {
        array[index] = value;
    }
}

Использование:

MyContainer<String> container = new MyContainer<>(String.class, 10);
container.set(0, "Hello");
String element = container.get(0); // Безопасно, без приведения

Решение 2: Массив Object[] с приведением

Если вы не хотите возиться с рефлексией, можно использовать внутренний массив Object[] и приводить при получении элемента:

public class MyContainer<T> {
    private Object[] array;

    public MyContainer(int size) {
        array = new Object[size];
    }

    @SuppressWarnings("unchecked")
    public T get(int index) {
        return (T) array[index];
    }

    public void set(int index, T value) {
        array[index] = value;
    }
}

Этот подход проще, но имеет недостаток: при get() мы получаем предупреждение "unchecked cast", так как компилятор не может гарантировать безопасность приведения. Однако на практике, если вы гарантируете, что в массив кладутся только элементы типа T, всё будет работать корректно.

Решение 3: Использование ArrayList вместо массива

Если вам не принципиально использовать именно массив, лучшим решением будет ArrayList<T>:

public class MyContainer<T> {
    private List<T> list;

    public MyContainer(int size) {
        list = new ArrayList<>(size);
    }

    public T get(int index) {
        return list.get(index);
    }

    public void set(int index, T value) {
        list.set(index, value);
    }
}

Это полностью типобезопасно, без предупреждений и рефлексии. ArrayList внутри использует массив Object[], но скрывает все приведение от вас.

Сравнение подходов

• Array.newInstance() — самый правильный способ, если нужен именно массив. Требует передачи Class<T>.
• Object[] с приведением — проще, но с предупреждением. Можно использовать с @SuppressWarnings.
• ArrayList — рекомендуется как альтернатива массиву в большинстве случаев.

Почему нельзя просто new T[size]?

Потому что дженерики в Java реализованы через стирание типов. Во время выполнения тип T заменяется на границу (Object, если не указано иное). Массивы же в Java знают свой тип во время выполнения, поэтому создание массива параметризованного типа противоречит этой концепции. Подробнее об этом можно почитать в спецификации Java (JLS §15.10.2).

import java.util.function.Supplier;
import java.lang.reflect.Array;

public class MyContainer<T> {
    private T[] array;

    @SuppressWarnings("unchecked")
    public MyContainer(Supplier<T> supplier, int size) {
        // Создаём массив Object[], затем приводим
        array = (T[]) new Object[size];
        // Инициализируем каждый элемент через supplier
        for (int i = 0; i < size; i++) {
            array[i] = supplier.get();
        }
    }
}

MyContainer<StringBuilder> container = 
    new MyContainer<>(StringBuilder::new, 5);