Matrices de copia de Java

En este tutorial, aprenderá sobre las diferentes formas que puede usar para copiar matrices (tanto unidimensionales como bidimensionales) en Java con la ayuda de ejemplos.

En Java, podemos copiar una matriz en otra. Hay varias técnicas que puede utilizar para copiar matrices en Java.

1. Copiar matrices usando el operador de asignación

Tomemos un ejemplo,

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 + ", ");
        }
    }
}

Salida :

1, 2, 3, 4, 5, 6

En el ejemplo anterior, hemos utilizado el operador de asignación (= ) para copiar una matriz llamada numbers a otra matriz llamada positiveNumbers .

Esta técnica es la más fácil y también funciona. Sin embargo, hay un problema con esta técnica. Si cambiamos elementos de una matriz, los elementos correspondientes de las otras matrices también cambian. Por ejemplo,

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 + ", ");
        }
    }
}

Salida :

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

Aquí, podemos ver que hemos cambiado un valor de los numbers formación. Cuando imprimimos los positiveNumbers matriz, podemos ver que el mismo valor también se cambia.

Es porque ambas matrices se refieren al mismo objeto de matriz. Esto se debe a la copia superficial. Para obtener más información sobre la copia superficial, visite la copia superficial.

Ahora, para crear nuevos objetos de matriz mientras se copian las matrices, necesitamos una copia profunda en lugar de una copia superficial.

2. Uso de construcción en bucle para copiar matrices

Tomemos un ejemplo:

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));
    }
}

Salida :

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

En el ejemplo anterior, hemos utilizado el for bucle para iterar a través de cada elemento de la matriz de origen. En cada iteración, estamos copiando elementos de la fuente array al destino matriz.

Aquí, la matriz de origen y destino se refieren a diferentes objetos (copia profunda). Por lo tanto, si se modifican los elementos de una matriz, los elementos correspondientes de otra matriz no se modifican.

Note la declaración,

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

Aquí, el método toString() se usa para convertir una matriz en una cadena. Para obtener más información, visite el método toString() (documentación oficial de Java).

3. Copiando arreglos usando el método arraycopy()

En Java, la clase System contiene un método llamado arraycopy() para copiar matrices. Este método es un mejor enfoque para copiar matrices que los dos anteriores.

El arraycopy() El método le permite copiar una parte específica de la matriz de origen en la matriz de destino. Por ejemplo,

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

Aquí,

origen - matriz de origen que desea copiar
srcPos - posición inicial (índice) en la matriz de origen
destino - matriz de destino donde los elementos se copiarán desde la fuente
POSDEST - posición inicial (índice) en la matriz de destino
longitud - número de elementos a copiar

Tomemos un ejemplo:

// 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));  
    }
}

Salida :

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

En el ejemplo anterior, hemos utilizado el arraycopy() método,

System.arraycopy(n1, 0, n2, 0, n1.length) - elementos completos del n1 la matriz se copia en n2 matriz
System.arraycopy(n1, 2, n3, 1, 2) - 2 elementos del n1 matriz a partir del índice 2 se copian en el índice a partir de 1 del n3 matriz

Como puede ver, el valor inicial predeterminado de los elementos de un int matriz de tipos es 0.

4. Copiando arreglos usando el método copyOfRange()

También podemos usar el método copyOfRange() definido en la clase Java Arrays para copiar matrices. Por ejemplo,

// 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));   
    }
}

Salida

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

En el ejemplo anterior, observe la línea,

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

Aquí podemos ver que estamos creando el destino1 array y copiando la fuente matriz a él al mismo tiempo. No estamos creando el destino1 matriz antes de llamar al copyOfRange() método. Para obtener más información sobre el método, visite Java copyOfRange.

5. Copiando Arrays 2d Usando Loop

Similar a la matriz unidimensional, también podemos copiar la matriz bidimensional usando el for círculo. 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) {

            // 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));  
      
    }
}

Salida :

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

En el programa anterior, observe la línea,

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

Aquí, el deepToString() El método se utiliza para proporcionar una mejor representación de la matriz bidimensional. Para obtener más información, visite Java deepToString().

Copiar arreglos 2d usando arraycopy()

Para simplificar el código anterior, podemos reemplazar el bucle interno con System.arraycopy() como en el caso de una matriz unidimensional. 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) {

             // 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));      
    }
}

Salida :

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

Aquí, podemos ver que obtenemos el mismo resultado reemplazando el for interno bucle con el arraycopy() método.

Matrices multidimensionales de Java Objetos y clases de Java

Java