Tableaux de copie Java

Dans ce didacticiel, vous découvrirez différentes manières de copier des tableaux (unidimensionnels et bidimensionnels) en Java à l'aide d'exemples.

En Java, nous pouvons copier un tableau dans un autre. Il existe plusieurs techniques que vous pouvez utiliser pour copier des tableaux en Java.

1. Copier des tableaux à l'aide de l'opérateur d'affectation

Prenons un exemple,

class Main {
    public static void main(String[] args) {
       
        int [] numbers = {1, 2, 3, 4, 5, 6};
        int [] positiveNumbers = numbers;    // copying arrays

        for (int number: positiveNumbers) {
            System.out.print(number + ", ");
        }
    }
}

Sortie :

1, 2, 3, 4, 5, 6

Dans l'exemple ci-dessus, nous avons utilisé l'opérateur d'affectation (= ) pour copier un tableau nommé numbers à un autre tableau nommé positifNumbers .

Cette technique est la plus simple et elle fonctionne aussi. Cependant, il y a un problème avec cette technique. Si nous changeons les éléments d'un tableau, les éléments correspondants des autres tableaux changent également. Par exemple,

class Main {
    public static void main(String[] args) {
      
        int [] numbers = {1, 2, 3, 4, 5, 6};
        int [] positiveNumbers = numbers;    // copying arrays
      
        // change value of first array
        numbers[0] = -1;

        // printing the second array
        for (int number: positiveNumbers) {
            System.out.print(number + ", ");
        }
    }
}

Sortie :

-1, 2, 3, 4, 5, 6

Ici, nous pouvons voir que nous avons changé une valeur des nombres déployer. Lorsque nous imprimons les positifNumbers tableau, nous pouvons voir que la même valeur est également modifiée.

C'est parce que les deux tableaux font référence au même objet tableau. C'est à cause de la copie superficielle. Pour en savoir plus sur la copie superficielle, consultez Copie superficielle.

Maintenant, pour créer de nouveaux objets de tableau tout en copiant les tableaux, nous avons besoin d'une copie approfondie plutôt que d'une copie superficielle.

2. Utilisation de la construction en boucle pour copier des tableaux

Prenons un exemple :

import java.util.Arrays;

class Main {
    public static void main(String[] args) {
      
        int [] source = {1, 2, 3, 4, 5, 6};
        int [] destination = new int[6];

        // iterate and copy elements from source to destination
        for (int i = 0; i < source.length; ++i) {
            destination[i] = source[i];
        }
      
         // converting array to string
        System.out.println(Arrays.toString(destination));
    }
}

Sortie :

[1, 2, 3, 4, 5, 6]

Dans l'exemple ci-dessus, nous avons utilisé le for boucle pour parcourir chaque élément du tableau source. À chaque itération, nous copions des éléments de la source tableau vers la destination tableau.

Ici, les tableaux source et destination font référence à des objets différents (copie profonde). Par conséquent, si les éléments d'un tableau sont modifiés, les éléments correspondants d'un autre tableau sont inchangés.

Remarquez la déclaration,

System.out.println(Arrays.toString(destination));

Ici, la méthode toString() est utilisée pour convertir un tableau en chaîne. Pour en savoir plus, visitez la méthode toString() (documentation Java officielle).

3. Copier des tableaux à l'aide de la méthode arraycopy()

En Java, la classe System contient une méthode nommée arraycopy() pour copier des tableaux. Cette méthode est une meilleure approche pour copier des tableaux que les deux précédentes.

Le arraycopy() La méthode vous permet de copier une partie spécifiée du tableau source dans le tableau de destination. Par exemple,

arraycopy(Object src, int srcPos,Object dest, int destPos, int length)

Ici,

source - tableau source que vous souhaitez copier
srcPos - position de départ (index) dans le tableau source
dest - tableau de destination où les éléments seront copiés depuis la source
PosDest - position de départ (index) dans le tableau de destination
longueur - nombre d'éléments à copier

Prenons un exemple :

// To use Arrays.toString() method
import java.util.Arrays;

class Main {
    public static void main(String[] args) {
        int[] n1 = {2, 3, 12, 4, 12, -2};
      
        int[] n3 = new int[5];

        // Creating n2 array of having length of n1 array
        int[] n2 = new int[n1.length];
      
        // copying entire n1 array to n2
        System.arraycopy(n1, 0, n2, 0, n1.length);
        System.out.println("n2 = " + Arrays.toString(n2));  
      
        // copying elements from index 2 on n1 array
        // copying element to index 1 of n3 array
        // 2 elements will be copied
        System.arraycopy(n1, 2, n3, 1, 2);
        System.out.println("n3 = " + Arrays.toString(n3));  
    }
}

Sortie :

n2 = [2, 3, 12, 4, 12, -2]
n3 = [0, 12, 4, 0, 0]

Dans l'exemple ci-dessus, nous avons utilisé le arraycopy() méthode,

System.arraycopy(n1, 0, n2, 0, n1.length) - des éléments entiers du n1 tableau sont copiés dans n2 tableau
System.arraycopy(n1, 2, n3, 1, 2) - 2 éléments du n1 tableau commençant par l'index 2 sont copiés dans l'index à partir de 1 du n3 tableau

Comme vous pouvez le voir, la valeur initiale par défaut des éléments d'un int le tableau de type est 0.

4. Copier des tableaux à l'aide de la méthode copyOfRange()

Nous pouvons également utiliser la méthode copyOfRange () définie dans la classe Java Arrays pour copier des tableaux. Par exemple,

// To use toString() and copyOfRange() method
import java.util.Arrays;

class ArraysCopy {
    public static void main(String[] args) {
      
        int[] source = {2, 3, 12, 4, 12, -2};
      
        // copying entire source array to destination
        int[] destination1 = Arrays.copyOfRange(source, 0, source.length);      
        System.out.println("destination1 = " + Arrays.toString(destination1)); 
      
        // copying from index 2 to 5 (5 is not included) 
        int[] destination2 = Arrays.copyOfRange(source, 2, 5); 
        System.out.println("destination2 = " + Arrays.toString(destination2));   
    }
}

Sortie

destination1 = [2, 3, 12, 4, 12, -2]
destination2 = [12, 4, 12]

Dans l'exemple ci-dessus, notez la ligne,

int[] destination1 = Arrays.copyOfRange(source, 0, source.length);

Ici, nous pouvons voir que nous créons la destination1 tableau et copie de la source tableau en même temps. Nous ne créons pas la destination1 tableau avant d'appeler le copyOfRange() méthode. Pour en savoir plus sur la méthode, visitez Java copyOfRange.

5. Copie de tableaux 2d à l'aide d'une boucle

Semblable au tableau unidimensionnel, nous pouvons également copier le tableau bidimensionnel en utilisant le for boucle. Par exemple,

import java.util.Arrays;

class Main {
    public static void main(String[] args) {
      
        int[][] source = {
              {1, 2, 3, 4}, 
              {5, 6},
              {0, 2, 42, -4, 5}
              };

        int[][] destination = new int[source.length][];

        for (int i = 0; i < destination.length; ++i) {

            // allocating space for each row of destination array
            destination[i] = new int[source[i].length];

            for (int j = 0; j < destination[i].length; ++j) {
                destination[i][j] = source[i][j];
            }
        }
     
        // displaying destination array
        System.out.println(Arrays.deepToString(destination));  
      
    }
}

Sortie :

[[1, 2, 3, 4], [5, 6], [0, 2, 42, -4, 5]]

Dans le programme ci-dessus, notez la ligne,

System.out.println(Arrays.deepToString(destination);

Ici, le deepToString() La méthode est utilisée pour fournir une meilleure représentation du tableau à 2 dimensions. Pour en savoir plus, visitez Java deepToString().

Copier des tableaux 2d à l'aide de arraycopy()

Pour simplifier le code ci-dessus, nous pouvons remplacer la boucle interne par System.arraycopy() comme dans le cas d'un tableau unidimensionnel. Par exemple,

import java.util.Arrays;

class Main {
    public static void main(String[] args) {
      
        int[][] source = {
              {1, 2, 3, 4}, 
              {5, 6},
              {0, 2, 42, -4, 5}
              };

        int[][] destination = new int[source.length][];

        for (int i = 0; i < source.length; ++i) {

             // allocating space for each row of destination array
             destination[i] = new int[source[i].length];
             System.arraycopy(source[i], 0, destination[i], 0, destination[i].length);
        }
     
        // displaying destination array
        System.out.println(Arrays.deepToString(destination));      
    }
}

Sortie :

[[1, 2, 3, 4], [5, 6], [0, 2, 42, -4, 5]]

Ici, nous pouvons voir que nous obtenons la même sortie en remplaçant le for intérieur boucle avec le arraycopy() méthode.

Tableaux multidimensionnels Java Classe et objets Java

Java