Faire une copie d'un tableau

J'ai un tableau aqui est constamment mis à jour. Disons a = [1,2,3,4,5]. Je dois faire une copie exacte de aet l'appeler b. Si aje devais changer [6,7,8,9,10], bje devrais l'être [1,2,3,4,5]. Quelle est la meilleure façon de procéder? J'ai essayé une forboucle comme:

for(int i=0; i<5; i++) {
    b[i]=a[i]
}

mais cela ne semble pas fonctionner correctement. Veuillez ne pas utiliser de termes avancés comme copie profonde, etc., car je ne sais pas ce que cela signifie.

Vous pouvez essayer d'utiliser System.arraycopy ()

int[] src  = new int[]{1,2,3,4,5};
int[] dest = new int[5];

System.arraycopy( src, 0, dest, 0, src.length );

Mais, probablement mieux d'utiliser clone () dans la plupart des cas:

int[] src = ...
int[] dest = src.clone();

vous pouvez utiliser

int[] a = new int[]{1,2,3,4,5};
int[] b = a.clone();

ainsi que.

Si vous souhaitez faire une copie de:

int[] a = {1,2,3,4,5};

C'est la voie à suivre:

int[] b = Arrays.copyOf(a, a.length);

Arrays.copyOfpeut être plus rapide que a.clone()sur les petits tableaux. Les deux éléments de copie sont également rapides mais clone () renvoie Objectdonc le compilateur doit insérer un transtypage implicite vers int[]. Vous pouvez le voir dans le bytecode, quelque chose comme ceci:

ALOAD 1
INVOKEVIRTUAL [I.clone ()Ljava/lang/Object;
CHECKCAST [I
ASTORE 2

Belle explication de http://www.journaldev.com/753/how-to-copy-arrays-in-java

Méthodes de copie de tableau Java

Object.clone () : la classe Object fournit la méthode clone () et puisque le tableau en java est également un objet, vous pouvez utiliser cette méthode pour obtenir une copie complète du tableau. Cette méthode ne vous conviendra pas si vous souhaitez une copie partielle du tableau.

System.arraycopy () : la classe système arraycopy () est la meilleure façon de faire une copie partielle d'un tableau. Il vous permet de spécifier facilement le nombre total d'éléments à copier et les positions d'index du tableau source et de destination. Par exemple, System.arraycopy (source, 3, destination, 2, 5) copiera 5 éléments de la source à la destination, en commençant du 3e index de la source au 2e index de la destination.

Arrays.copyOf (): si vous souhaitez copier les premiers éléments d'un tableau ou une copie complète du tableau, vous pouvez utiliser cette méthode. Évidemment, ce n'est pas polyvalent comme System.arraycopy () mais ce n'est pas non plus déroutant et facile à utiliser.

Arrays.copyOfRange () : Si vous voulez que quelques éléments d'un tableau soient copiés, où l'index de départ n'est pas 0, vous pouvez utiliser cette méthode pour copier un tableau partiel.

J'ai le sentiment que toutes ces "meilleures façons de copier un tableau" ne vont pas vraiment résoudre votre problème.

Vous dites

J'ai essayé une boucle for comme [...] mais cela ne semble pas fonctionner correctement?

En regardant cette boucle, il n'y a aucune raison évidente pour qu'elle ne fonctionne pas ... à moins que:

• vous avez en quelque sorte les tableaux aet bfoirés (par exemple aet faites bréférence au même tableau), ou
• votre application est multithread et différents threads lisent et mettent à jour le atableau simultanément.

Dans les deux cas, d'autres façons de faire la copie ne résoudront pas le problème sous-jacent.

La solution pour le premier scénario est évidente. Pour le deuxième scénario, vous devrez trouver un moyen de synchroniser les threads. Les classes de tableaux atomiques n'aident pas car elles n'ont pas de constructeurs de copie atomique ou de méthodes de clonage, mais la synchronisation à l'aide d'un mutex primitif fera l'affaire.

(Il y a des indices dans votre question qui m'amènent à penser que c'est effectivement lié au thread; par exemple, votre déclaration qui achange constamment.)

Vous pouvez essayer d'utiliser Arrays.copyOf () en Java

int[] a = new int[5]{1,2,3,4,5};
int[] b = Arrays.copyOf(a, a.length);

Toutes les solutions qui appellent la longueur du tableau, ajoutez votre code redondant null checkersconsider exemple:

int[] a = {1,2,3,4,5};
int[] b = Arrays.copyOf(a, a.length);
int[] c = a.clone();

//What if array a comes as local parameter? You need to use null check:

public void someMethod(int[] a) {
    if (a!=null) {
        int[] b = Arrays.copyOf(a, a.length);
        int[] c = a.clone();
    }
}

Je vous recommande de ne pas inventer la roue et d'utiliser la classe utilitaire où toutes les vérifications nécessaires ont déjà été effectuées. Considérez ArrayUtils d'apache commons. Votre code devient plus court:

public void someMethod(int[] a) {
    int[] b = ArrayUtils.clone(a);
}

Apache commons vous pouvez y trouver

Vous pouvez également utiliser Arrays.copyOfRange.

Exemple :

public static void main(String[] args) {
    int[] a = {1,2,3};
    int[] b = Arrays.copyOfRange(a, 0, a.length);
    a[0] = 5;
    System.out.println(Arrays.toString(a)); // [5,2,3]
    System.out.println(Arrays.toString(b)); // [1,2,3]
}

Cette méthode est similaire à Arrays.copyOf, mais elle est plus flexible. Les deux utilisent System.arraycopysous le capot.

Voir :

• https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html
• https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html
• http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8u40-b25/java/util/Arrays.java?av=f

Pour une copie null-safe d'un tableau, vous pouvez également utiliser une option avec la Object.clone()méthode fournie dans cette réponse .

int[] arrayToCopy = {1, 2, 3};
int[] copiedArray = Optional.ofNullable(arrayToCopy).map(int[]::clone).orElse(null);

Si vous devez travailler avec des tableaux bruts et non ArrayListalors Arraysa ce que vous avez besoin. Si vous regardez le code source, ce sont les meilleures façons d'obtenir une copie d'un tableau. Ils ont une bonne programmation défensive parce que la System.arraycopy()méthode lève beaucoup d'exceptions non contrôlées si vous lui donnez des paramètres illogiques.

Vous pouvez utiliser l'un ou l'autre Arrays.copyOf()qui copiera du premier Nthélément vers le nouveau tableau plus court.

public static <T> T[] copyOf(T[] original, int newLength)

Copie le tableau spécifié, en le tronquant ou en le remplissant avec des valeurs nulles (si nécessaire) afin que la copie ait la longueur spécifiée. Pour tous les index valides à la fois dans le tableau d'origine et dans la copie, les deux tableaux contiendront des valeurs identiques. Pour tous les index valides dans la copie mais pas l'original, la copie contiendra null. De tels indices existeront si et seulement si la longueur spécifiée est supérieure à celle du tableau d'origine. Le tableau résultant est exactement de la même classe que le tableau d'origine.

2770
2771    public static <T,U> T[] More ...copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
2772        T[] copy = ((Object)newType == (Object)Object[].class)
2773            ? (T[]) new Object[newLength]
2774            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
2775        System.arraycopy(original, 0, copy, 0,
2776                         Math.min(original.length, newLength));
2777        return copy;
2778    }

ou Arrays.copyOfRange()fera aussi l'affaire:

public static <T> T[] copyOfRange(T[] original, int from, int to)

Copie la plage spécifiée du tableau spécifié dans un nouveau tableau. L'index initial de la plage (de) doit être compris entre zéro et la longueur d'origine, inclus. La valeur à l'original [de] est placée dans l'élément initial de la copie (sauf de == original.length ou de == to). Les valeurs des éléments suivants du tableau d'origine sont placées dans les éléments suivants de la copie. L'index final de la plage (to), qui doit être supérieur ou égal à from, peut être supérieur à original.length, auquel cas null est placé dans tous les éléments de la copie dont l'index est supérieur ou égal à original. longueur - de. La longueur du tableau retourné sera de - de. Le tableau résultant est exactement de la même classe que le tableau d'origine.

3035    public static <T,U> T[] More ...copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
3036        int newLength = to - from;
3037        if (newLength < 0)
3038            throw new IllegalArgumentException(from + " > " + to);
3039        T[] copy = ((Object)newType == (Object)Object[].class)
3040            ? (T[]) new Object[newLength]
3041            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
3042        System.arraycopy(original, from, copy, 0,
3043                         Math.min(original.length - from, newLength));
3044        return copy;
3045    }

Comme vous pouvez le voir, ces deux fonctions ne sont que des fonctions d'encapsulation System.arraycopyavec une logique défensive selon laquelle ce que vous essayez de faire est valide.

System.arraycopy est le moyen le plus rapide de copier des tableaux.

J'ai eu un problème similaire avec les tableaux 2D et je me suis arrêté ici. Je copiais le tableau principal et modifiais les valeurs des tableaux internes, et j'ai été surpris lorsque les valeurs ont changé dans les deux copies. Fondamentalement, les deux copies étaient indépendantes mais contenaient des références aux mêmes tableaux internes et j'ai dû créer un tableau de copies des tableaux internes pour obtenir ce que je voulais.

Ce n'est probablement pas le problème du PO, mais j'espère qu'il pourra toujours être utile.