Copier un tableau en Java

Java

Copier un tableau en Java | Programmes de tableau en Java – 9 | Dans le programme Java précédent, nous avons vu comment comparer deux tableaux en Java. Maintenant, dans ce post, nous verrons Java Array Copy | Comment cloner ou copier un tableau en Java ? Comment copier un tableau 2D en Java ? Quelles sont les différentes manières de copier des tableaux en Java ? Ici, nous aborderons tous ces points.

Il existe diverses méthodes intégrées telles que System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange() et la méthode clone() qui peuvent être utilisées pour copier un tableau en Java. Nous pouvons également copier manuellement en affectant chaque élément à un autre élément du tableau. Voyons-les un par un.

Copie superficielle d'un tableau en Java à l'aide de l'opérateur d'affectation (=)

Nous pouvons copier un tableau en Java en utilisant l'opérateur d'affectation (=). Démontrons-le à travers un exemple.

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = {10, 20, 30, 40, 50};
      
      // copy array using assignment operator
      int newArr[] = arr;
      
      // display array
      System.out.println("Original Array = " 
                        + Arrays.toString(arr));
      System.out.println("Copied Array = " 
                        + Arrays.toString(newArr));
   }
}

Sortie :-

Tableau d'origine =[10, 20, 30, 40, 50]
Tableau copié =[10, 20, 30, 40, 50]

Pour afficher le tableau, nous avons utilisé la méthode toString() qui est donnée dans la classe java.util.Arrays. Mais vous pouvez également utiliser des boucles comme la boucle for, la boucle for-each, etc. Voir :- Différentes façons d'imprimer/d'afficher un tableau en Java.

C'est un exemple de copie superficielle . En copie superficielle, la référence du tableau est affectée au nouveau tableau.

Limitation de cette approche :- Si nous modifions le contenu du tableau d'origine, le contenu du tableau nouvellement créé changera également. Le programme ci-dessous démontre ce point,

// original array
int arr[] = {10, 20, 30, 40, 50};

// copy array using assignment operator
int newArr[] = arr;

// display array (Before Modification)
System.out.println("Before Modification,");
System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

// modifying content of original array
arr[0] = 555;
arr[3] = 777;

// display array (After Modification)
System.out.println("\nAfter Modification,");
System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

Sortie :-

Avant modification,
Matrice originale =[10, 20, 30, 40, 50]
Matrice copiée =[10, 20, 30, 40, 50]

Après modification,
Matrice originale =[555, 20, 30, 777, 50]
Matrice copiée =[555, 20, 30, 777, 50]

Copie en profondeur d'un tableau en Java à l'aide de boucles

Pour créer une copie complète du tableau en Java à l'aide de la boucle, nous devons effectuer les opérations suivantes :-
1) Créez un nouveau tableau avec un type de données et une taille similaires.
2) Utilisez la boucle pour itérer dans le tableau d'origine.
3) Copiez le ième élément du tableau d'origine dans le ième élément du nouveau tableau.

Avant de créer un nouveau tableau, commencez par calculer la taille du tableau d'origine. La propriété length du tableau peut être utilisée pour calculer la taille d'un tableau en Java. Maintenant, démontrons la copie complète du tableau à l'aide de boucles.

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = { 10, 20, 30, 40, 50 };

      // create new array with similar type and size
      int newArr[] = new int[arr.length];

      // copy using loop
      for (int i = 0; i < arr.length; i++) {
         // copy elements
         newArr[i] = arr[i];
      }

      // display array
      System.out.println("Original Array = " 
                          + Arrays.toString(arr));
      System.out.println("Copied Array = " 
                          + Arrays.toString(newArr));
   }
}

Sortie :-

Tableau d'origine =[10, 20, 30, 40, 50]
Tableau copié =[10, 20, 30, 40, 50]

Dans une copie complète, chaque élément du tableau d'origine est affecté à un nouveau tableau, donc chaque fois que nous modifions le contenu du tableau d'origine, les éléments du tableau nouvellement créé ne seront pas affectés.

// original array
int arr[] = { 10, 20, 30, 40, 50 };

// create new array with similar type and size
int newArr[] = new int[arr.length];

// copy using loop
for (int i = 0; i < arr.length; i++) {
   // copy elements
   newArr[i] = arr[i];
}

// display array (Before Modification)
System.out.println("Before Modification,");
System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

// modifying content of original array
arr[0] = 555;
arr[3] = 777;

// display array (After Modification)
System.out.println("\nAfter Modification,");
System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

Sortie :-

Avant modification,
Matrice originale =[10, 20, 30, 40, 50]
Matrice copiée =[10, 20, 30, 40, 50]

Après modification,
Matrice d'origine =[555, 20, 30, 777, 50]
Matrice copiée =[10, 20, 30, 40, 50]

Copier un tableau en Java à l'aide de System.arraycopy()

La méthode System.arraycopy() en Java est donné pour copier un tableau dans un autre tableau. Il copie un tableau du tableau source spécifié, en commençant à la position spécifiée, vers la position spécifiée du tableau de destination.

Syntaxe de la méthode arraycopy() dans la classe java.lang.System :- public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

Dans cette syntaxe,

src :- Le tableau source.
srcPos :- Position de départ dans le tableau source.
dest : le tableau de destination.
destPos : position de départ dans les données de destination.
longueur : le nombre d'éléments du tableau à copier.

Étant donné que la classe java.lang.System est importée par défaut dans toutes les classes Java, il n'est donc pas nécessaire d'importer explicitement la classe System pour utiliser la méthode arraycopy().

Programme pour copier un tableau en Java en utilisant la méthode System.arraycopy()

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = { 10, 20, 30, 40, 50 };

      // create new array with similar type and size
      int newArr[] = new int[arr.length];

      // copy array using System.arraycopy
      System.arraycopy(arr, 0, newArr, 0, arr.length);

      System.out.println("Original Array = " + Arrays.toString(arr));
      System.out.println("Copied Array = " + Arrays.toString(newArr));
   }

}

Sortie :-

Tableau d'origine =[10, 20, 30, 40, 50]
Tableau copié =[10, 20, 30, 40, 50]

Il effectue une copie superficielle du tableau. Cela signifie que lorsque arraycopy() est appliqué à des tableaux non primitifs, il copie les références d'objet plutôt que les données d'objet.

Dans son post respectif de la méthode System.arraycopy(), nous avons déjà vérifié ce point à travers le tableau 2D et en utilisant un tableau d'objets. Encore une fois dans ce post, nous le verrons en discutant de la copie du tableau 2D.

Remarque : - L'arraycopy() est probablement le moyen le plus rapide pour copier un tableau, et cela donne de meilleures performances par rapport à la copie de tableau normale à l'aide de boucles. C'est dans le système car il utilise une copie directe de la mémoire en dehors de Java Land. La classe java.lang.System fournit des méthodes utiles pour l'entrée et la sortie standard, pour charger des fichiers et des bibliothèques ou pour accéder à des propriétés définies en externe.

Copier un tableau en Java à l'aide de la méthode Arrays.copyOf()

La méthode copyOf() de la classe java.util.Arrays en Java copie le tableau spécifié, en tronquant ou en remplissant avec des zéros/nulls (si nécessaire). En interne, cette méthode appelle la méthode System.arraycopy() .

Il y a un total de 10 formes surchargées de la méthode Arrays.copyOf(). Certains d'entre eux sont donnés ci-dessous. Les formes surchargées restantes de la méthode Arrays.copyOf() sont implémentées de la même manière. La méthode copyOf() avec toutes ses formes surchargées a été introduite dans la version Java 1.6 .

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

Dans ces méthodes, les paramètres sont,

original : le tableau à copier.
newLength : la longueur de la copie à renvoyer.

Programme pour copier un tableau en Java en utilisant la méthode Arrays.copyOf(),

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = { 10, 20, 30, 40, 50 };

      // copy array using Arrays.copyOf()
      int[] newArr = Arrays.copyOf(arr, arr.length);

      System.out.println("Original Array = " + Arrays.toString(arr));
      System.out.println("Copied Array = " + Arrays.toString(newArr));
   }

}

Sortie :-

Tableau d'origine =[10, 20, 30, 40, 50]
Tableau copié =[10, 20, 30, 40, 50]

Points supplémentaires,

Cette méthode lève NullPointerException si le tableau d'origine passé est nul. Par conséquent, il est préférable de vérifier if(original !=null) puis d'appeler copyOf().
Il lève également NegativeArraySizeException si la longueur transmise (c'est-à-dire newLength) est négative.

Depuis la méthode Arrays.copyOf() en interne en utilisant System.arraycopy() par conséquent, il effectue également une copie superficielle.

Copier le tableau en Java à l'aide de la méthode Arrays.copyOfRange()

Semblable à la méthode Arrays.copyOf(), nous pouvons également utiliser la méthode Arrays.copyOfRange() . Les deux méthodes sont très similaires et la méthode copyOfRange() effectue une opération de copie uniquement dans la plage spécifiée. Semblable à la méthode copyOf() en interne, elle utilise également System.arraycopy() et effectue la copie superficielle . Il existe de nombreuses formes surchargées de cette méthode,

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

Dans cette méthode, les paramètres sont,

original : le tableau à partir duquel une plage doit être copiée.
from :- L'index initial de la plage à copier, il est inclus.
à :- l'index final de la plage à copier, exclusif. Cet index peut se trouver en dehors du tableau.

La méthode copyOfRange() renvoie un nouveau tableau contenant la plage spécifiée du tableau d'origine, tronqué ou rempli de zéros pour obtenir la longueur requise. Démontrons-le à travers un exemple.

Programme pour copier un tableau en Java en utilisant la méthode Arrays.copyOfRange()

// original array
int arr[] = { 10, 20, 30, 40, 50 };

// copy array 
int[] newArr = Arrays.copyOfRange(arr, 0, arr.length);

System.out.println("Original Array = " + Arrays.toString(arr));
System.out.println("Copied Array = " + Arrays.toString(newArr));

Tableau d'origine =[10, 20, 30, 40, 50]
Tableau copié =[10, 20, 30, 40, 50]

Clone de tableau Java

Nous pouvons également effectuer une copie de tableau en Java en utilisant la méthode clone() de la classe java.lang.Object. La méthode clone() de la classe java.lang.Object effectue une copie superficielle . Cela signifie que lorsque clone() est appliqué à des tableaux non primitifs, il copie les références d'objet plutôt que les données d'objet. Démontrons-le à travers un exemple,

Copier le tableau en Java à l'aide de la méthode clone()

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      int arr[] = { 10, 20, 30, 40, 50 };

      // copy array using clone()
      int[] newArr = arr.clone();
       
      // display array (Before Modification)
      System.out.println("Before Modification,");
      System.out.println("Original Array = " + Arrays.toString(arr));
      System.out.println("Copied Array = " + Arrays.toString(newArr));

      // modifying content of original array
      arr[0] = 555;
      arr[3] = 777;

      // display array (After Modification)
      System.out.println("\nAfter Modification,"); 
      System.out.println("Original Array = " + Arrays.toString(arr));
      System.out.println("Copied Array = " + Arrays.toString(newArr));
   }
}

Sortie :-

Avant modification,
Matrice originale =[10, 20, 30, 40, 50]
Matrice copiée =[10, 20, 30, 40, 50]

Après modification,
Matrice d'origine =[555, 20, 30, 777, 50]
Matrice copiée =[10, 20, 30, 40, 50]

Plus d'exemples

Tous les exemples précédents utilisent un tableau de type int. Voyons un exemple d'un type de tableau différent. Ici, nous allons démontrer la méthode System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange() dans un seul exemple. Pour démontrer chaque méthode, décommentez-la et commentez les deux approches restantes.

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {
      // original array
      String str[] = {"Java", "Python", "C++"};

      // copy array using System.arraycopy()
      String[] newArr = new String[str.length];
      System.arraycopy(str, 0, newArr, 0, str.length);
      
      // copy using Arrays.copyOf()
      // String[] newArr = Arrays.copyOf(str, str.length);
      
      // copy using clone()
      // String[] newArr = str.clone();
      
      // display array (Before Modification)
      System.out.println("Before Modification,");
      System.out.println("Original Array = " + Arrays.toString(str));
      System.out.println("Copied Array = " + Arrays.toString(newArr));

      // modifying content of original array
      str[0] = "C#";
      str[2] = "HTML";

      // display array (After Modification)
      System.out.println("\nAfter Modification,"); 
      System.out.println("Original Array = " + Arrays.toString(str));
      System.out.println("Copied Array = " + Arrays.toString(newArr));
   }

}

Sortie :-

Avant modification,
Original Array =[Java, Python, C++]
Copied Array =[Java, Python, C++]

Après modification,
Original Array =[ C#, Python, HTML]
Tableau copié =[Java, Python, C++]

Copier un tableau 2D en Java

Dans tous les exemples précédents, nous copions le tableau unidimensionnel. Voyons maintenant différentes approches pour copier le tableau multidimensionnel en Java. Nous allons démontrer tous ces points à travers un tableau à deux dimensions.

Copie superficielle d'un tableau 2D en Java

Programme Java pour copier un tableau bidimensionnel (2D) en Java à l'aide de la méthode System.arraycopy(),

import java.util.Arrays;

public class CopyArray {
   public static void main(String[] args) {

      // original 2D array 3x2
      int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

      // destination array
      int dest[][] = new int[3][2];

      // copy array using System.arraycopy
      System.arraycopy(src, 0, dest, 0, src.length);

      // display both array
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                          + Arrays.deepToString(dest) );

   }
}

Sortie :-

Tableau source =[[ 1, 2], [ 4, 5], [ 7, 8]]
Tableau destination =[[ 1, 2], [ 4, 5], [ 7, 8]]

Programme Java pour copier en deux dimensions 2D tableau en Java utilisant Tableaux.copyOf () méthode,

// original 2D array 3x2
int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

// copy array using Arrays.copyOf()
int dest[][] = Arrays.copyOf(src, src.length);

// display both array
System.out.println("Source array = " + Arrays.deepToString(src));
System.out.println("Destination array =" +Arrays.deepToString(dest));

Sortie :-

Tableau source =[[ 1, 2], [ 4, 5], [ 7, 8]]
Tableau destination =[[ 1, 2], [ 4, 5], [ 7, 8]]

Programme Java pour copier un tableau 2D bidimensionnel en Java en utilisant la méthode Arrays.copyOfRange(),

// original 2D array 3x2
int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

// copy array 
int dest[][] = Arrays.copyOfRange(src, 0, src.length);

// display both array
System.out.println("Source array = " + Arrays.deepToString(src));
System.out.println("Destination array = "+Arrays.deepToString(dest));

Tableau source =[[ 1, 2], [ 4, 5], [ 7, 8]]
Tableau destination =[[ 1, 2], [ 4, 5], [ 7, 8]]

Programme Java pour copier en deux dimensions 2D Tableau en Java utilisant méthode clone() ,

// 2D array 3x2
int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

// copy array using clone()
int dest[][] = src.clone();

// display array
System.out.println("Source array = " + Arrays.deepToString(src));
System.out.println("Destination array = " + Arrays.deepToString(dest));

Tableau source =[[ 1, 2], [ 4, 5], [ 7, 8]]
Tableau destination =[[ 1, 2], [ 4, 5], [ 7, 8]]

Limites de ces approches

Les méthodes System.arraycopy(), Arrays.copyOf(), Arrays.copyOfRange() et clone() effectuent une copie superficielle, ce qui peut créer plusieurs problèmes. Démontrons-le à travers un exemple :-

import java.util.Arrays;

public class CopyArray {

   public static void main(String[] args) {

      // original array
      int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };
      
      // copy array using System.arraycopy()
      int dest[][] = new int[3][2];
      System.arraycopy(src, 0, dest, 0, src.length);
      
      // copy array using Arrays.copyOf()
      // int dest[][] = Arrays.copyOf(src, src.length);
      
      // copy array using clone()
      // int dest[][] = src.clone();

      // display array (Before Modification)
      System.out.println("Before Modification,");
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                        + Arrays.deepToString(dest));

      // modify original array
      src[0][0] = 999;
      src[1][1] = 888;

      // display array (After Modification)
      System.out.println("\nAfter Modification,");
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                        + Arrays.deepToString(dest));
   }
}

Sortie :-

Avant modification,
Tableau source =[[ 1, 2], [ 4, 5], [ 7, 8]]
Tableau destination =[[ 1, 2], [ 4, 5], [ 7, 8]]

Après modification,
Tableau source =[[ 999, 2], [ 4 888], [ 7, 8]]
Tableau destination =[[ 999, 2], [ 4 888], [ 7, 8]]

Copie en profondeur d'un tableau 2D en Java

Nous pouvons effectuer une copie en profondeur à l'aide de boucles. Pour ce faire, parcourez le tableau multidimensionnel et copiez chaque élément dans le nouveau tableau. Voyons cela à travers un exemple. Dans ce programme, nous allons écrire une logique pour copier un tableau à l'intérieur de la méthode. Voir :- Comment trouver la taille/longueur d'un tableau 2D

import java.util.Arrays;

public class CopyArray {

   // copy multidimensional array using loop (deep copy)
   public static int[][] copy(int[][] src) {
      // create 2D array and assign size of parent array
      int temp[][] = new int[src.length][];

      for (int i = 0; i < src.length; i++) {
         // assign size of child array
         temp[i] = new int[src[i].length];

         for (int j = 0; j < src[i].length; j++) {
            // copy element
            temp[i][j] = src[i][j];
         }
      }

      // return
      return temp;
   }

   public static void main(String[] args) {

      // original 2D array 3x2
      int src[][] = { { 1, 2 }, { 4, 5 }, { 7, 8 } };

      // copy array 
      int dest[][] = copy(src);

      // display both array
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                    + Arrays.deepToString(dest));

      // modify original array
      src[0][0] = 999;
      src[1][1] = 888;

      // display array (After Modification)
      System.out.println("\nAfter Modification,");
      System.out.println("Source array = " + Arrays.deepToString(src));
      System.out.println("Destination array = " 
                    + Arrays.deepToString(dest));

   }

}

Sortie :-

Puisque nous prenons l'exemple d'un tableau 2D de nombres entiers, nous pouvons également utiliser les méthodes System.arraycopy(), Arrays.copyOf() et Arrays.copyOfRange() pour copier le tableau 1D.

Notez que ces méthodes effectuent une copie superficielle uniquement lorsque le tableau donné n'est pas primitif. Cela signifie que lorsque ces méthodes sont appliquées à des tableaux non primitifs, seules les références d'objet sont copiées plutôt que les données d'objet. Mais la matrice ou notre tableau 2D dans cet exemple contient un tableau de valeurs int à la deuxième dimension. Par conséquent, nous pouvons les utiliser comme suit :-

// copy multidimensional array (deep copy)
public static int[][] copy(int[][] src) {
      
   // create 2D array and assign size of parent array
   int temp[][] = new int[src.length][];

   for (int i = 0; i < src.length; i++) {
      // copy second dimensional array
      temp[i] = Arrays.copyOf(src[i], src[i].length); 
   }

   // return
   return temp;
}

Remplacez cette méthode par la méthode précédente. La sortie pour cette fois,