Copia de arreglos de Java

En este tutorial, aprenderá diferentes métodos disponibles para copiar arrays (unidimensionales y bidimensionales) en Java con la ayuda de ejemplos.

　En Java, podemos copiar un array a otro array. Hay varias técnicas que se pueden usar para copiar arrays en Java.

1.Uso del operador de asignación para copiar el array

Vamos a dar un ejemplo

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

Salida:

1,　2,　3,　4,　5,　6

　En el ejemplo anterior, usamos el operador de asignación (=) para copiar un array llamado numbers a otro array llamado positiveEnumbers.

　Esta técnica es la más simple y también efectiva. Sin embargo, esta técnica tiene un problema. Si cambiamos un elemento de un array, los elementos correspondientes de otros arrays también cambiarán. Por ejemplo,

class Main {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] numbers = {1,　2,　3,　4,　5,　6};
　　　　　　　　int[] positiveNumbers = numbers;　　　　//Copiar el array
　　　　　　
　　　　　　　　//Cambiar el valor del primer array
　　　　　　　　numbers[0] =　-1;
　　　　　　　　//Imprimir el segundo array
　　　　　　　　for (int number : positiveNumbers) {
　　　　　　　　　　　　System.out.print(number　+　"");
　　　　　　　　}
　　　　}
}

Salida:

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

　Aquí, podemos ver que hemos cambiado un valor del array numbers. Cuando imprimimos el array positiveNumbers, podemos ver que también se ha cambiado el mismo valor.

Esto se debe a que ambos arrays apuntan al mismo objeto de array. Esto se debe a la copia superficial. Para obtener más información sobre la copia superficial, visiteCopia superficial。

Ahora, para crear un nuevo objeto de array mientras copiamos el array, necesitamos una copia profunda en lugar de una copia superficial.

2Uso de bucles para construir la copia del array

el número de elementos a copiar

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= new int[
　　　　　　　　//Iteración y copia de elementos desde la fuente al destino
　　　　　　　　for　(int　i　=　0;　i　<　source.length;　++i)　{
　　　　　　　　　　　　for (int i = 0; i < source.length;
　　　　　　　　}
　　　　　　
　　　　　　　　　//destination[i] = source[i];
　　　　　　　　NOTA las siguientes instrucciones,
　　　　}
}

Salida:

convertir el array en una cadena1,　2,　3,　4,　5,　6]

[

En el ejemplo anterior, utilizamos un bucle for para recorrer cada elemento del array de origen. En cada iteración, copiamos el elemento del array source al array destination.

en este caso, las referencias de los arrays de origen y destino son diferentes (copia profunda). Por lo tanto, si se cambia un elemento de un array, el elemento correspondiente del otro array también se mantendrá inmutable.

NOTA las siguientes instrucciones,

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

3en este caso, el método toString() se utiliza para convertir el array en una cadena.

.copiar arrays usando el método arraycopy()en Java,la clase System

　el paquete contiene un método llamado arraycopy() para copiar arrays. En comparación con los dos métodos anteriores, este es un método mejor para copiar arrays.

el método permite copiar una parte específica del array de origen al array de destino. Por ejemplo,

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

• aquí, -src

• el array de origen que desea copiar -srcPos

• la posición de inicio (índice) en el array de origen -dest

• el array de destino, se copiarán los elementos desde el origen -destPos

• la posición de inicio (índice) en el array de destino -length

el número de elementos a copiar

//Vamos a dar un ejemplo:
import java.util.Arrays;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　int[] n1　usando el método Arrays.toString()2,　3,　12,　4,　12,　-2};
　　　　　　
　　　　　　　　int[] n3　= {5= new int[
　　　　　　　　//];1crea un array de longitud n2el array
　　　　　　　　int[] n2　= new int[n1.length];
　　　　　　
　　　　　　　　//copiar todo el n1copiar el array al n2
　　　　　　　　System.arraycopy(n1, 0, n2, 0, n1.length);
　　　　　　　　System.out.println("n2　= "　+　Arrays.toString(n2));　　
　　　　　　
　　　　　　　　　//desde n1los índices del array2copiar elementos
　　　　　　　　　//se copiarán los elementos al n3los índices del array1
　　　　　　　　//se copiarán2elementos
　　　　　　　　System.arraycopy(n1,　2, n3,　1,　2);
　　　　　　　　System.out.println("n3　= "　+　Arrays.toString(n3));　　
　　　　}
}

Salida:

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

En el ejemplo anterior, utilizamos el método arraycopy()

• System.arraycopy(n1, 0, n2, 0, n1.length) - copiar n1se copia el elemento completo del array al n2en el array

• System.arraycopy(n1, 2, n3, 1, 2 )-　 desde el índice2empezando por n1dos elementos del array se copian desde n3el array1en el índice de inicio

Como puede ver, el valor inicial por defecto de los elementos del array de tipo int es 0.

4. Copiar el array usando el método copyOfRange()

También podemos usarJava Arraysusar el método copyOfRange() definido en la clase para copiar el array. Por ejemplo,

//Usar métodos toString() y copyOfRange()
import java.util.Arrays;
class ArraysCopy {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] source = {2,　3,　12,　4,　12,　-2};
　　　　　　
　　　　　　　　//copiar todo el array de origen al destino
　　　　　　　　int[] destination1　= Arrays.copyOfRange(source, 0, source.length);　　　　　　
　　　　　　　　System.out.println("destination1　= "　+　Arrays.toString(destination1));　
　　　　　　
　　　　　　　　//desde el índice2copiar hasta5（不包括5)　
　　　　　　　　int[] destination2　= Arrays.copyOfRange(source,　2,　5);　
　　　　　　　　System.out.println("destination2　= "　+　Arrays.toString(destination2));　　　
　　　　}
}

Resultados de salida

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

En el ejemplo anterior, preste atención a las siguientes líneas:

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

Aquí, podemos ver que estamos creando destination1copiar un array y al mismo tiempo copiar el array de origen a él. Antes de llamar al método copyOfRange(), no crearemos destination1Para obtener más información sobre este método, visitemétodo copyOfRange de Java。

5. Copiar un array bidimensional usando un bucle

Al igual que con un array unidimensional, también podemos usar un bucle for para copiar un array bidimensional. Por ejemplo,

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)　{
　　　　　　　　　　　　//Asignar espacio para cada fila del array de destino
　　　　　　　　　　　　destination[i]　=　new　int[source[i].length];
　　　　　　　　　　　　for (int j = 0; j < destination[i].length;　++j) {
　　　　　　　　　　　　　　　　destination[i][j] = source[i][j];
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　
　　　　　　　　//Mostrar el array de destino
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　
　　　　　　
　　　　}
}

Salida:

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

En el programa anterior, preste atención a las siguientes líneas:

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

Aquí, se utiliza el método deepToString() para proporcionar una mejor representación de un array bidimensional. Para obtener más información, visitedeepToString() de Java。

Copiar un array bidimensional usando arraycopy()

Para simplificar el código anterior, podemos usar System.arraycopy() para reemplazar el bucle interno, al igual que con un array unidimensional. Por ejemplo, por ejemplo,

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)　{
　　　　　　　　　　　　　//Asignar espacio para cada fila del array de destino
　　　　　　　　　　　　　destination[i]　=　new　int[source[i].length];
　　　　　　　　　　　　　System.arraycopy(source[i],　0,　destination[i],　0,　destination[i].length);
　　　　　　　　}
　　　　　
　　　　　　　　//Mostrar el array de destino
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　　　　　
　　　　}
}

Salida:

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

　Aquí, podemos ver que al reemplazar el bucle for interno con el método arraycopy(), podemos obtener la misma salida.