.toArray(new MyClass[0]) ou .toArray(new MyClass[myList.size()]) ?

Question

En supposant que j'ai une ArrayList

ArrayList myList;

Et que je veux appeler toArray, y a-t-il une raison de performance à utiliser

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

plutôt que

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

?

Je préfère le deuxième style, car il est moins verbeux, et j'ai supposé que le compilateur se chargerait de s'assurer que le tableau vide ne serait pas réellement créé, mais je me demandais si c'était vrai.

Bien sûr, dans 99% des cas, cela ne fait pas de différence d'une manière ou d'une autre, mais j'aimerais garder un style cohérent entre mon code normal et mes boucles internes optimisées...

Answer 1

À partir de ArrayList en Java 5, le tableau sera déjà rempli s'il a la bonne taille (ou plus grande). En conséquence

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

créera un objet tableau, le remplira et le renverra à "arr". En revanche

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

créera deux tableaux. Le second est un tableau de MyClass de longueur 0. Ainsi, il y a une création d'objet pour un objet qui sera jeté immédiatement. À en juger par le code source, le compilateur / JIT ne peut pas optimiser celui-ci de sorte qu'il ne soit pas créé. De plus, l'utilisation de l'objet de longueur zéro entraîne des conversions implicites dans la méthode toArray().

Voir la source de ArrayList.toArray():

public  T[] toArray(T[] a) {
    if (a.length < size)
        // Créer un nouveau tableau de type d'exécution de a, mais avec mes éléments :
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

Utilisez la première méthode pour ne créer qu'un seul objet et éviter les conversions (implicitement mais néanmoins coûteuses).

Answer 2

Les JVM modernes optimisent la construction réfléchie de tableaux dans ce cas, donc la différence de performance est minime. Nommer la collection deux fois dans un tel code d'amorçage n'est pas une bonne idée, donc je éviterais la première méthode. Un autre avantage de la seconde est qu'elle fonctionne avec des collections synchronisées et concurrentes. Si vous souhaitez optimiser, réutilisez le tableau vide (les tableaux vides sont immuables et peuvent être partagés), ou utilisez un profileur(!).

Answer 3

ToArray vérifie que le tableau passé est de la bonne taille (c'est-à-dire suffisamment grand pour contenir les éléments de votre liste) et, le cas échéant, l'utilise. Par conséquent, si la taille du tableau fourni est inférieure à celle requise, un nouveau tableau sera créé de manière réflexive.

Dans votre cas, un tableau de taille zéro est immuable, il pourrait donc être élevé en tant que variable statique finale, ce qui rendrait votre code un peu plus propre en évitant de créer le tableau à chaque invocation. Un nouveau tableau sera de toute façon créé à l'intérieur de la méthode, il s'agit donc d'une optimisation de lisibilité.

On pourrait arguer que la version la plus rapide est de passer le tableau de la bonne taille, mais sauf si vous pouvez prouver que ce code est un goulot d'étranglement en termes de performances, privilégiez la lisibilité à la performance d'exécution jusqu'à preuve du contraire.

Answer 4

Le premier cas est plus efficace.

Cela est dû au fait que dans le deuxième cas :

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

le runtime crée réellement un tableau vide (de taille zéro) et ensuite, à l'intérieur de la méthode toArray, crée un autre tableau pour s'adapter aux données réelles. Cette création est effectuée en utilisant la réflexion en utilisant le code suivant (extraite de jdk1.5.0_10) :

public  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;
}

En utilisant la première forme, vous évitez la création d'un deuxième tableau et évitez également le code de réflexion.

Answer 5

Le compilateur ne fera pas d'optimisation. Très probablement, il s'agira d'une optimisation du compilateur JIT à l'exécution et cela dépendra de votre JVM.

Personnellement, j'utilise l'ancienne version. Ce n'est pas aussi verbeux.