Est-il préférable d'utiliser System.arraycopy(...) qu'une boucle for pour copier des tableaux?

Question

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

Ils ne peuvent pas être nuls, mais leur taille peut être 0.

Je ne peux pas choisir entre ces deux façons : 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

``

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

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

Est-ce vraiment plus rapide si ce n'est pas pour les types natifs : 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 ?

Dans une autre question liée, ils disent que la taille compte énormément, pour une taille >24 system.arraycopy() l'emporte, pour moins de 10, la boucle manuelle est meilleure...

Maintenant je suis vraiment confus.

``

Answer 1

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 les tests de performances, mais
testHardCopyBytes a pris 0,157s pour être complété
et
testArrayCopyBytes a pris 0,086s pour être complété.

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

EDIT:
Il semble que les performances de System.arraycopy soient aléatoires. Lorsque des chaînes de caractères sont utilisées au lieu de bytes, et que les tableaux sont petits (taille 10), Je reçois ces résultats:

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

Voici ce que cela donne lorsque les tableaux ont une taille de 0x1000000. Il semble que System.arraycopy gagne définitivement avec de plus grands tableaux.

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

Quelle curiosité!

Merci Daren d'avoir souligné que les références sont copiées différemment. Cela a rendu ce problème beaucoup plus intéressant!

Answer 2

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

Vous ne pouvez pas le rendre plus rapide!

Answer 3

Cela dépend de la machine virtuelle, mais System.arraycopy devrait vous donner les performances les plus proches du natif.

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

Answer 4

Exécuter des méthodes natives comme Arrays.copyOf(T[], int) a un certain surcoût, 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 banc d'essai et de tester.

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

Le code de benchmark provenant de ici :-

public void test(int copySize, int copyCount, int testRep) {
    System.out.println("Taille de la copie = " + copySize);
    System.out.println("Nombre de copies = " + 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), donc c'est extrêmement rapide, comme vous pouvez le confirmer ici

Answer 5

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