.toArray (новый MyClass[0]) или .toArray (новый MyClass [myList.size ()])?

С ArrayList в Java 5, массив уже будет заполнен, если он будет иметь правильный размер (или больше). Следовательно

MyClass[] arr = myList.toArray(new MyClass[myList.size()]);

создаст один объект массива, заполнит его и возвратит его "прибытию". С другой стороны

MyClass[] arr = myList.toArray(new MyClass[0]);

создаст два массива. Второй является массивом MyClass с длиной 0. Таким образом, существует создание объекта для объекта, который будет сразу выброшен. Насколько исходный код предлагает компилятор / JIT не может оптимизировать этого так, чтобы он не был создан. Кроме того, использование нулевой длины возражает результатам на кастинге (кастингах) в toArray () - метод.

Посмотрите источник ArrayList.toArray ():

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

Использование первый метод так, чтобы только один объект был создан и избежал (неявный, но тем не менее дорогой) кастингов.

Современные JVMs оптимизируют отражающую конструкцию массива в этом случае, таким образом, различие в производительности является крошечным. Именование набора дважды в таком шаблонном коде не является прекрасной идеей, таким образом, я избежал бы первого метода. Другое преимущество второго состоит в том, что это работает с синхронизируемыми и параллельными наборами. Если Вы хотите сделать оптимизацию, снова использовать пустой массив (пустые массивы неизменны и могут быть совместно использованы), или используйте профилировщика (!).

Используя 'toArray' с массивом корректного размера будет работать лучше, поскольку альтернатива создаст сначала нуль измеренный массив затем массив корректного размера. Однако, поскольку Вы говорите, что различие, вероятно, будет незначительно.

Кроме того, обратите внимание, что javac компилятор не выполняет оптимизации. В эти дни вся оптимизация выполняется компиляторами JIT/горячей точки во времени выполнения. Я не знаю ни о какой оптимизации вокруг 'toArray' ни в каком JVMs.

Ответ на Ваш вопрос, затем, является в основном вопросом стиля, но для пользы непротиворечивости должен явиться частью любых стандартов кодирования, Вы придерживаетесь (или зарегистрированный или иначе).

toArray проверяет, что массив передал, имеет правильный размер (то есть, достаточно большой для установки элементам из списка) и если так, использование это. Следовательно, если размер массива обеспечил его меньший, чем необходимый, новый массив будет рефлексивно создан.

В Вашем случае, массиве нулевого размера, неизменно, так мог безопасно быть поднят до статической последней переменной, которая могла бы сделать Ваш код немного более чистым, который старается не создавать массив на каждом вызове. Новый массив будет создан в методе так или иначе, таким образом, это будет оптимизация удобочитаемости.

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

Первый случай более эффективен.

Это вызвано тем, что во втором случае:

MyClass[] arr = myList.toArray(new MyClass[0]);

время выполнения на самом деле создает пустой массив (с нулевым размером), и затем в toArray методе создает другой массив для установки фактическим данным. Это создание сделано с помощью отражения с помощью следующего кода (взятый от jdk1.5.0_10):

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        a = (T[])java.lang.reflect.Array.
    newInstance(a.getClass().getComponentType(), size);
System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

При помощи первой формы Вы избегаете создания второго массива и также избегаете отражательного кода.