Vaut-il mieux utiliser System.arraycopy (…) qu'une boucle for pour copier des tableaux?

Je veux créer un nouveau tableau d'objets rassemblant deux tableaux plus petits.

Ils ne peuvent pas être nuls, mais la taille peut être égale à 0.

Je ne peux pas choisir entre ces deux méthodes: sont-elles équivalentes ou l'une est-elle plus efficace (par exemple, system.arraycopy () copie des morceaux entiers)?

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
System.arraycopy(publicThings, 0, things, 0, publicThings.length);
System.arraycopy(privateThings, 0, things,  publicThings.length, privateThings.length);

ou

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
for (int i = 0; i < things.length; i++) {
    if (i<publicThings.length){
        things[i] = publicThings[i]
    } else {
        things[i] = privateThings[i-publicThings.length]        
    }
}

La seule différence est-elle l'aspect du code?

EDIT: merci pour la question liée, mais ils semblent avoir une discussion non résolue:

Est-ce vraiment plus rapide si it is not for native types: byte [], Object [], char []? dans tous les autres cas, une vérification de type est exécutée, ce qui serait mon cas et donc serait équivalent ... non?

Sur une autre question liée, ils disent que the size matters a lot, pour une taille> 24 system.arraycopy () gagne, pour moins de 10, le manuel pour la boucle est meilleur ...

Maintenant, je suis vraiment confus.

public void testHardCopyBytes()
{
    byte[] bytes = new byte[0x5000000]; /*~83mb buffer*/
    byte[] out = new byte[bytes.length];
    for(int i = 0; i < out.length; i++)
    {
        out[i] = bytes[i];
    }
}

public void testArrayCopyBytes()
{
    byte[] bytes = new byte[0x5000000]; /*~83mb buffer*/
    byte[] out = new byte[bytes.length];
    System.arraycopy(bytes, 0, out, 0, out.length);
}

Je sais que les tests JUnit ne sont pas vraiment les meilleurs pour l'analyse comparative, mais
testHardCopyBytes a pris 0,157 s pour terminer
et
testArrayCopyBytes a pris 0,086 s pour terminer.

Je pense que cela dépend de la machine virtuelle, mais il semble que cela copie des blocs de mémoire au lieu de copier des éléments de tableau unique. Cela augmenterait absolument les performances.

EDIT:
Il semble que les performances de System.arraycopy soient partout. Lorsque des chaînes sont utilisées au lieu d'octets et que les tableaux sont petits (taille 10), j'obtiens ces résultats:

    String HC:  60306 ns
    String AC:  4812 ns
    byte HC:    4490 ns
    byte AC:    9945 ns

Voici à quoi cela ressemble lorsque les tableaux sont à la taille 0x1000000. Il semble que System.arraycopy gagne définitivement avec des tableaux plus grands.

    Strs HC:  51730575 ns
    Strs AC:  24033154 ns
    Bytes HC: 28521827 ns
    Bytes AC: 5264961 ns

Comme c'est étrange!

Merci Daren d'avoir signalé que les références se copient différemment. Cela en a fait un problème beaucoup plus intéressant!

Arrays.copyOf(T[], int)est plus facile à lire. En interne, il utilise System.arraycopy()ce qui est un appel natif.

Vous ne pouvez pas l'obtenir plus rapidement!

Cela dépend de la machine virtuelle, mais System.arraycopy devrait vous fournir le plus proche possible des performances natives.

J'ai travaillé pendant 2 ans en tant que développeur java pour les systèmes embarqués (où les performances sont une priorité absolue) et partout où System.arraycopy pouvait être utilisé, je l'ai principalement utilisé / vu utilisé dans du code existant. Il est toujours préférable aux boucles lorsque les performances sont un problème. Si les performances ne sont pas un gros problème, je suivrais la boucle. Beaucoup plus facile à lire.

Au lieu de me fier à des spéculations et peut-être à des informations obsolètes, j'ai exécuté des tests de étrier. En fait, Caliper est livré avec quelques exemples, dont un CopyArrayBenchmarkqui mesure exactement cette question! Tout ce que tu as à faire c'est courir

mvn exec:java -Dexec.mainClass=com.google.caliper.runner.CaliperMain -Dexec.args=examples.CopyArrayBenchmark

Mes résultats sont basés sur la VM serveur 64 bits Java HotSpot (TM) d'Oracle, 1.8.0_31-b13, fonctionnant sur un MacBook Pro mi-2010 (macOS 10.11.6 avec Intel Arrandale i7, 8 Gio de RAM). Je ne pense pas qu'il soit utile de publier les données de synchronisation brutes. Je vais plutôt résumer les conclusions avec les visualisations à l'appui.

En résumé:

• Écrire une forboucle manuelle pour copier chaque élément dans un tableau nouvellement instancié n'est jamais avantageux, que ce soit pour des tableaux courts ou des tableaux longs.
• Arrays.copyOf(array, array.length)et array.clone()sont tous les deux toujours rapides. Ces deux techniques sont presque identiques en performance; celui que vous choisissez est une question de goût.
• System.arraycopy(src, 0, dest, 0, src.length)est presque aussi rapide que et , mais pas tout à fait systématiquement. (Voir le cas pour 50000 s.) À cause de cela, et de la verbosité de l'appel, je recommanderais si vous avez besoin d'un contrôle précis sur quels éléments sont copiés et où.Arrays.copyOf(array, array.length)array.clone()intSystem.arraycopy()

Voici les graphiques de synchronisation:

L'exécution de méthodes natives comme Arrays.copyOf(T[], int)cela a une surcharge, mais cela ne signifie pas que ce n'est pas rapide car vous l'exécutez en utilisant JNI.

Le moyen le plus simple est d'écrire un benchmark et un test.

Vous pouvez vérifier que Arrays.copyOf(T[], int)c'est plus rapide que votre forboucle normale .

Le code de référence d' ici : -

public void test(int copySize, int copyCount, int testRep) {
    System.out.println("Copy size = " + copySize);
    System.out.println("Copy count = " + copyCount);
    System.out.println();
    for (int i = testRep; i > 0; --i) {
        copy(copySize, copyCount);
        loop(copySize, copyCount);
    }
    System.out.println();
}

public void copy(int copySize, int copyCount) {
    int[] src = newSrc(copySize + 1);
    int[] dst = new int[copySize + 1];
    long begin = System.nanoTime();
    for (int count = copyCount; count > 0; --count) {
        System.arraycopy(src, 1, dst, 0, copySize);
        dst[copySize] = src[copySize] + 1;
        System.arraycopy(dst, 0, src, 0, copySize);
        src[copySize] = dst[copySize];
    }
    long end = System.nanoTime();
    System.out.println("Arraycopy: " + (end - begin) / 1e9 + " s");
}

public void loop(int copySize, int copyCount) {
    int[] src = newSrc(copySize + 1);
    int[] dst = new int[copySize + 1];
    long begin = System.nanoTime();
    for (int count = copyCount; count > 0; --count) {
        for (int i = copySize - 1; i >= 0; --i) {
            dst[i] = src[i + 1];
        }
        dst[copySize] = src[copySize] + 1;
        for (int i = copySize - 1; i >= 0; --i) {
            src[i] = dst[i];
        }
        src[copySize] = dst[copySize];
    }
    long end = System.nanoTime();
    System.out.println("Man. loop: " + (end - begin) / 1e9 + " s");
}

public int[] newSrc(int arraySize) {
    int[] src = new int[arraySize];
    for (int i = arraySize - 1; i >= 0; --i) {
        src[i] = i;
    }
    return src;
}

System.arraycopy()utilise JNI (Java Native Interface) pour copier un tableau (ou des parties de celui-ci), il est donc extrêmement rapide, comme vous pouvez le confirmer ici

Il n'est pas possible que ce Arrays.copyOfsoit plus rapide que System.arraycopypuisqu'il s'agit de la mise en œuvre de copyOf:

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

System.arraycopy()est un appel natif qui effectue une opération de copie directement en mémoire. Une copie de mémoire unique serait toujours plus rapide que votre boucle for