Неужели плохая практика состоит в создании общих массивов, и какова будет альтернатива?

Ответ 1

Это не то, что это плохая идея сама по себе; это просто, что дженерики и массивы не очень хорошо смешиваются.

Причина связана с ковариацией и инвариантностью. Массивы являются ковариантными (Integer[] является Object[], потому что Integer является Object, но общие классы являются инвариантными (List<Integer> не является List<Object>, хотя Integer является Object).

Вам также нужно иметь дело с неконтролируемыми бросками, которые преследуют цель создания дженериков. Наиболее распространенный способ создания общего массива - E[] foo = (E[]) new Object[10]; - не является безопасным для типов и не может быть применен во время компиляции. Это можно рассуждать во время выполнения, но в этот момент теряются проверки времени компиляции, которые генерируют дженерики в таблице.

Чтобы ответить на вопрос напрямую, где и когда это возможно, вы хотите использовать "Коллекции Java" , поскольку они очень хорошо играют с генериками.

Просто взглянув на предоставленный вами код, я полагаю, что использование List<T> вместо T[] приведет вас к большинству ваших проблем (и я надеюсь, что вы передадите ArrayList, поскольку эти операции могут стать дорогой со связанным списком).

Ответ 2

Неплохая практика создания общего массива, но делать это правильно, так громоздкие люди обычно избегают этого.

Причина громоздкости в том, что дженерики стираются, а массивы - заново. То есть, параметры типа стираются во время компиляции, тогда как тип компонентов массивов сохраняется. Поэтому среда выполнения знает тип компонента каждого массива, но забыла аргументы типа всех объектов, то есть строку

E[] array = new E[10];

не компилируется, потому что среда выполнения должна знать тип компонента для нового массива, но забыл, что был E is.

Обходной путь в Макото:

E[] array = (E[]) new Object[10];

не является хорошей идеей, поскольку она фактически создает Object[], но затем притворяется компилятором, который является E[]. Поскольку забытое время выполнения было E, этот прилив также преуспевает во время выполнения, хотя он не правильный. Тем не менее, среда выполнения по-прежнему обеспечивает безопасность памяти, выполняя дополнительную проверку, как только она может, т.е. Когда объект хранится в переменной, тип которой не является общей. Например:

static <E> E[] createArray(int size) {
    return (E[]) new Object[size];
}

public static void main(String[] args) {
    String[] array = createArray(size); // throws ClassCastException
    for (String s : array) {
        // whatever
    }
}

То есть, это обходное решение - это взлом, который работает только при определенных обстоятельствах и в противном случае вызывает недоумение (ClassCastException в строке кода, который не содержит литье...).

Единственный способ создать E[] - через отражение, предоставляя объект класса желаемого типа компонента:

Class<E> eClass = ...;
E[] array = Arrays.newInstance(eClass, 10);

но как мы можем получить этот объект класса? Если наш вызывающий абонент знает, они могут передать нам литерал класса (например, Integer.class), или мы можем использовать отражение на каком-то другом объекте. В вашем случае у вас есть еще E[], так что вы можете спросить, какой массив E:

E[] originalArray = ...;
Class<E> eClass = (Class<E>) originalArray.getClass().getComponentType();
E[] newArray = (E[]) Array.newInstance(eClass, size);

Это гарантирует, что новый массив будет иметь тот же тип, что и старый, который является E[], если только кто-то не солгал нам о типе этого массива с использованием метода Макото.

Как вы можете видеть, можно создать общий массив, но он настолько громоздкий, что люди обычно идут на большие расстояния, чтобы избежать этого. Обычная альтернатива - использование массива некоторого супер-типа (в вашей сортировке слияния Comparable[] может работать даже лучше, чем Object[], потому что вам не нужно было бы делать бросок) или вместо ArrayList.

Ответ 3

Добавляя к ответ Makoto, я бы сказал, что Arrays являются ковариантными из-за того, что их информация о типе доступна во время выполнения, тогда как общие классы являются инвариантными, поскольку информация типа недоступна из-за типа стирание во время компиляции.

Ковариантные массивы: -

Object[] covariantArrays = new String[5];
covariantArrays[0] = new Dog(); // will give java.lang.ArrayStoreException

Инвариантные массивы: -

List invariantArrays   = new List<String>();
invariantArrays.add(new Dog());   // Works fine as type information is not available

По этой причине общие массивы не идут хорошо, так как Generics ограничены защитой типа компиляции, а массивы имеют доступную информацию о реальном типе даже во время выполнения