Copie de tableau Java

Dans ce tutoriel, vous découvrirez différentes méthodes utilisables pour copier des tableaux en Java (unidimensionnels et bidimensionnels) à l'aide d'exemples.

　En Java, nous pouvons copier un tableau dans un autre tableau. Il existe plusieurs techniques pour copier un tableau en Java.

1.Copiez l'array en utilisant l'opérateur d'affectation

Laissez-nous prendre un exemple

class Main {
　　　　public static void main(String[] args) {
　　　　　　　
　　　　　　　　int[] numbers = {1,　2,　3,　4,　5,　6};
　　　　　　　　int[] positiveNumbers = numbers;　　　　//Copiez l'array
　　　　　　　　for (int number : positiveNumbers) {
　　　　　　　　　　　　System.out.print(number　+　"");
　　　　　　　　}
　　　　}
}

Output:

1,　2,　3,　4,　5,　6

　Dans l'exemple ci-dessus, nous utilisons l'opérateur d'affectation (=) pour copier un tableau nommé numbers dans un autre tableau nommé positiveEnumbers.

　Cette technique est la plus simple, mais elle est tout aussi efficace. Cependant, cette technique a un problème. Si nous changeons un élément d'un tableau, l'élément correspondant de l'autre tableau changera également. Par exemple,

class Main {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] numbers = {1,　2,　3,　4,　5,　6};
　　　　　　　　int[] positiveNumbers = numbers;　　　　//Copiez l'array
　　　　　　
　　　　　　　　//Modifiez la valeur du premier tableau
　　　　　　　　numbers[0] =　-1;
　　　　　　　　//Imprimez le deuxième tableau
　　　　　　　　for (int number : positiveNumbers) {
　　　　　　　　　　　　System.out.print(number　+　"");
　　　　　　　　}
　　　　}
}

Output:

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

　Ici, nous pouvons voir que nous avons modifié une valeur du tableau numbers. Lorsque nous imprimons le tableau positiveNumbers, nous pouvons voir que la même valeur a également été modifiée.

C'est parce que les deux tableaux référencent le même objet d'array. C'est à cause de la copie superficielle. Pour en savoir plus sur la copie superficielle, veuillez visiterCopie superficielle。

Maintenant, pour créer un nouveau tableau d'objets lors de la copie de l'array, nous devons faire une copie profonde plutôt qu'une copie superficielle.

2Utilisez une boucle pour construire la copie de l'array

Laissez-nous prendre 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];
　　　　　　　　//Itère et copie les éléments de la source vers la destination
　　　　　　　　for (int i = 0; i < source.length;　++i)　{
　　　　　　　　　　　　destination[i] = source[i];
　　　　　　　　}
　　　　　　
　　　　　　　　　//Convertir le tableau en chaîne de caractères
　　　　　　　　System.out.println(Arrays.toString(destination));
　　　　}
}

Output:

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

Dans cet exemple, nous avons utilisé une boucle for pour parcourir chaque élément du tableau source. À chaque itération, nous copions l'élément du tableau source vers le tableau destination.

Dans ce cas, les références des tableaux source et cible sont des objets différents (copie en profondeur). Par conséquent, si un élément d'un tableau est modifié, l'élément correspondant de l'autre tableau restera inchangé.

Remarquez les instructions suivantes,

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

Dans ce cas, la méthode toString() est utilisée pour convertir le tableau en chaîne de caractères.

3Utiliser la méthode arraycopy() pour copier le tableau

En Java,Classe SystemContient une méthode appelée arraycopy() pour copier le tableau. Comparée aux deux autres méthodes, cette méthode est une meilleure méthode pour copier le tableau.

　La méthode permet de copier une partie spécifique du tableau source dans le tableau cible. Par exemple,

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

Ici,

• src -Tableau source que vous souhaitez copier

• srcPos -Position de début dans le tableau source (indice)

• dest -Tableau cible, à partir duquel les éléments seront copiés

• destPos -Position de début dans le tableau cible (indice)

• length -Nombre d'éléments à copier

Laissez-nous prendre un exemple :

//Utiliser la méthode Arrays.toString()
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];
　　　　　　　　//Créer une longueur de n1de la longueur n2tableau
　　　　　　　　int[] n2　= new int[n1.length];
　　　　　　
　　　　　　　　//Copier tout n1Copier le tableau dans n2
　　　　　　　　System.arraycopy(n1, 0, n2, 0, n1.length);
　　　　　　　　System.out.println("n2　= "　+　Arrays.toString(n2));　　
　　　　　　
　　　　　　　　　//à partir de n1l'indice du tableau2Copier l'élément
　　　　　　　　　//Copier l'élément dans n3l'indice du tableau1
　　　　　　　　//Copier2éléments
　　　　　　　　System.arraycopy(n1,　2, n3,　1,　2);
　　　　　　　　System.out.println("n3　= "　+　Arrays.toString(n3));　　
　　　　}
}

Output:

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

Dans cet exemple, nous avons utilisé la méthode arraycopy()

• System.arraycopy(n1, 0, n2, 0, n1.length) - Copier n1tous les éléments du tableau sont copiés à partir de n2dans le tableau

• System.arraycopy(n1, 2, n3, 1, 2 )-　 从索引2dans l'indice de début n1deux éléments du tableau sont copiés à partir de n3tableau1dans l'indice de début

Comme vous le voyez, la valeur initiale par défaut d'un tableau d'entiers est 0.

4.Copier un tableau en utilisant la méthode copyOfRange()

Nous pouvons également utiliserJava ArraysPar exemple, utiliser la méthode copyOfRange() définie dans la classe pour copier le tableau. Par exemple,

//Utiliser les méthodes toString() et copyOfRange()
import java.util.Arrays;
class ArraysCopy {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] source = {2,　3,　12,　4,　12,　-2};
　　　　　　
　　　　　　　　//Copier tout le tableau source dans la cible
　　　　　　　　int[] destination1　= Arrays.copyOfRange(source, 0, source.length);　　　　　　
　　　　　　　　System.out.println("destination1　= "　+　Arrays.toString(destination1));　
　　　　　　
　　　　　　　　//从索引2复制到5（不包括5)　
　　　　　　　　int[] destination2　= Arrays.copyOfRange(source,　2,　5);　
　　　　　　　　System.out.println("destination2　= "　+　Arrays.toString(destination2));　　　
　　　　}
}

Résultat de la sortie

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

Dans l'exemple ci-dessus, veuillez noter les lignes suivantes :

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

Dans ce cas, nous pouvons voir que nous créons destination1Copier un tableau et copier le tableau source en même temps. Nous ne créons pas destination avant d'appeler la méthode copyOfRange()1Pour plus d'informations sur cette méthode, veuillez consulterJava copyOfRange。

5.Copier un tableau deux dimensions en utilisant une boucle

Comme pour un tableau à une dimension, nous pouvons également utiliser une boucle for pour copier un tableau deux dimensions. 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)　{
　　　　　　　　　　　　//Allocate space for each row of the target array
　　　　　　　　　　　　destination[i]　=　new　int[source[i].length];
　　　　　　　　　　　　for (int j = 0; j < destination[i].length;　++j) {
　　　　　　　　　　　　　　　　destination[i][j] = source[i][j];
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　
　　　　　　　　//Display the target array
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　
　　　　　　
　　　　}
}

Output:

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

Dans le programme ci-dessus, veuillez noter les lignes suivantes :

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

Dans ce cas, l'utilisation de la méthode deepToString() fournit une meilleure représentation des tableaux deux dimensions. Pour plus d'informations, veuillez consulterJava deepToString()。

Copier un tableau deux dimensions en utilisant arraycopy()

Pour rendre le code ci-dessus plus simple, nous pouvons utiliser System.arraycopy() pour remplacer la boucle interne, comme on le fait pour un tableau à une dimension. Par exemple, 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)　{
　　　　　　　　　　　　　//Allocate space for each row of the target array
　　　　　　　　　　　　　destination[i]　=　new　int[source[i].length];
　　　　　　　　　　　　　System.arraycopy(source[i],　0,　destination[i],　0,　destination[i].length);
　　　　　　　　}
　　　　　
　　　　　　　　//Display the target array
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　　　　　
　　　　}
}

Output:

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

　Here, we can see that by replacing the internal for loop with the arraycopy() method, the same output can be obtained.