Qu'est-ce qui est le plus efficace ? System.arraycopy ou Arrays.copyOf ?

Question

En toArray méthode dans ArrayList Bloch utilise les deux System.arraycopy y Arrays.copyOf pour copier un tableau.

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

Comment puis-je comparer ces deux méthodes de copie et quand dois-je utiliser l'une ou l'autre ?

Answer 1

La différence est que Arrays.copyOf ne se contente pas de copier des éléments, elle crée également un nouveau tableau. System.arraycopy copie dans un tableau existant.

Voici la source pour Arrays.copyOf comme vous pouvez le voir, il utilise System.arraycopy en interne pour remplir le nouveau tableau :

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

Answer 2

Alors que System.arraycopy est implémenté de manière native, et peut donc être 1 plus rapide qu'une boucle Java, il n'est pas toujours aussi rapide qu'on pourrait le penser. Prenons cet exemple :

Object[] foo = new Object[]{...};
String[] bar = new String[foo.length];

System.arraycopy(foo, 0, bar, 0, bar.length);

Dans ce cas, le foo y bar Les tableaux ont des types de base différents, de sorte que l'implémentation de la fonction arraycopy doit vérifier le type de chaque référence copiée pour s'assurer qu'il s'agit bien d'une référence à une instance de String. Cela est nettement plus lent qu'une simple méthode de style C. memcopy du contenu du tableau.

L'autre point est que Arrays.copyOf utiliza System.arraycopy sous le capot. C'est pourquoi System.arraycopy es à première vue ne devrait pas être plus lent 2 que Arrays.copyOf . Mais vous pouvez voir (à partir du code cité au-dessus de ) que Arrays.copyOf utilisera dans certains cas la réflexion pour créer le nouveau tableau. La comparaison des performances n'est donc pas simple.

Cette analyse présente quelques failles.

1. Nous examinons le code d'implémentation d'une version spécifique de Java. Ces méthodes peuvent changer, invalidant les hypothèses précédentes sur l'efficacité.

2. Nous ignorons la possibilité que le compilateur JIT puisse effectuer une optimisation intelligente des cas particuliers pour ces méthodes. Et il semble que cela se produise avec Arrays.copyOf ; voir Pourquoi Arrays.copyOf est-il 2 fois plus rapide que System.arraycopy pour les petits tableaux ? . Cette méthode est "intrinsèque" dans les implémentations Java de la génération actuelle, ce qui signifie que le compilateur JIT ignorera ce qui se trouve dans le code source Java !

Mais de toute façon, le différence entre les deux versions est O(1) (c'est-à-dire indépendante de la taille du tableau) et relativement petite. Par conséquent, je vous conseille d'utiliser la version qui rend votre code le plus facile à lire, et de ne vous préoccuper de la version la plus rapide que dans les cas suivants profilage vous dit que ça compte.

---

1 - Il podría être plus rapide, mais il est également possible que le compilateur JIT fait un si bon travail d'optimisation d'une boucle codée à la main qu'il n'y a aucune différence.

Answer 3

Si vous voulez un exact d'un tableau (par exemple, si vous voulez faire une copie défensive), la manière la plus efficace de copier un tableau est probablement d'utiliser la fonction clone() método:

class C {
    private int[] arr;
    public C(int[] values){
        this.arr = values.clone();
    }
}

Je n'ai pas pris la peine de tester les performances de ce système, mais il a de bonnes chances d'être assez rapide puisqu'il est entièrement natif (allocation et copie en appel), et que le clonage est une sorte de méthode spéciale bénie par la JVM pour copier des objets (et c'est surtout mauvais pour d'autres usages) et est susceptible de prendre quelques "raccourcis".

Personnellement, j'utiliserais toujours clone si c'était plus lent que n'importe quelle autre façon de copier, parce que c'est plus facile à lire et presque impossible de se tromper en écrivant. System.arrayCopy d'un autre côté...

Answer 4

System.arrayCopy est beaucoup plus rapide. Il est dans le système parce qu'il utilise une copie directe de la mémoire en dehors de la terre de Java. Utilisez-la quand c'est possible.

Answer 5

Avez-vous regardé l'implémentation de Arrays.copyOf() chez Sun ?

 public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

Comme on peut le voir, il utilise System.arraycopy() en interne, donc les performances seraient les mêmes.