¿Cómo copio una matriz de 2 dimensiones en Java?

Question

Necesito hacer una copia de una matriz bidimensional bastante grande para un proyecto en el que estoy trabajando. Tengo dos matrices en 2D:

int[][]current; 
int[][]old; 

También tengo dos métodos para hacer la copia. Necesito copiar la matriz porque la corriente se actualiza regularmente.

public void old(){ 
    old=current 
} 

y

public void keepold(){ 
    current=old 
} 

Sin embargo, esto no funciona. Si tuviera que llamar al viejo, actualizar el actual, y luego llamar a keepold, el actual no es igual a lo que era originalmente. ¿Por qué sería esto?

Gracias

Answer 1

current=old o old=current hace que la matriz de dos se refieren a la misma cosa, por lo que si posteriormente se modifica current, old se modificará también. Para copiar el contenido de una matriz a otra matriz, utiliza el bucle for

for(int i=0; i<old.length; i++) 
    for(int j=0; j<old[i].length; j++) 
    old[i][j]=current[i][j]; 

PS: Para una matriz unidimensional, puede evitar la creación de su propio bucle mediante el uso de Arrays.copyOf

Answer 2

current = old ; 

operaciones de asignación doesnot elementos de copias de una matriz a otra. Solo está haciendo que la matriz current haga referencia a la matriz old. Necesita hacer una copia sabia de miembro.

Answer 3

matrices en Java son objetos, y todos los objetos son passed by reference. Con el fin de realmente "copia" de una matriz, en lugar de crear otro nombre para una matriz, usted tiene que ir y crear una nueva matriz y copiar todos los valores. Tenga en cuenta que System.arraycopy copiará matrices de 1 dimensión totalmente, pero NO matrices de 2 dimensiones. La razón es que una matriz 2D es en realidad un conjunto de matrices 1D 1D, y copias arraycopy más punteros a las mismas matrices 1D internos.

Answer 4

Usted puede dar a continuación código de prueba,

public void multiArrayCopy(int[][] source,int[][] destination){ 
destination=source.clone();} 

Espero que funcione.

Answer 5

lo resolví escribir una simple función para copiar matrices multidimensionales usando int System.arraycopy

public static void arrayCopy(int[][] aSource, int[][] aDestination) { 
    for (int i = 0; i < aSource.length; i++) { 
     System.arraycopy(aSource[i], 0, aDestination[i], 0, aSource[i].length); 
    } 
} 

o realmente he mejorado por el uso de mi caso:

/** 
* Clones the provided array 
* 
* @param src 
* @return a new clone of the provided array 
*/ 
public static int[][] cloneArray(int[][] src) { 
    int length = src.length; 
    int[][] target = new int[length][src[0].length]; 
    for (int i = 0; i < length; i++) { 
     System.arraycopy(src[i], 0, target[i], 0, src[i].length); 
    } 
    return target; 
} 

Answer 6

/** 
* Clones the provided array 
* 
* @param src 
* @return a new clone of the provided array 
*/ 
public static int[][] cloneArray(int[][] src) { 
    int length = src.length; 
    int[][] target = new int[length][src[0].length]; 
    for (int i = 0; i < length; i++) { 
     System.arraycopy(src[i], 0, target[i], 0, src[i].length); 
    } 
    return target; 
} 

¿es posible modificar este código para apoyar n-dimensio nales matrices de objetos?

Usted tendría que soportar longitudes arbitrarias de matrices y comprobar si el src y de destino tienen las mismas dimensiones, y también tendría que copiar cada elemento de cada matriz recursiva, en caso de que el objeto era también una matriz .

Ha sido un tiempo desde que he publicado esto, pero me encontré con un nice example de una manera de crear una clase de matriz n-dimensional. La clase toma cero o más enteros en el constructor, especificando el tamaño respectivo de cada dimensión. La clase utiliza una matriz subyacente matriz Object[] y calcula el índice de cada elemento utilizando las dimensiones y una matriz de multiplicadores. (Así es como las matrices se realizan en el lenguaje de programación C.)

Copiar una instancia de NDimensionalArray sería tan fácil como copiar cualquier otra matriz 2D, aunque debe afirmar que cada objeto NDimensionalArray tiene las mismas dimensiones. Esta es probablemente la forma más fácil de hacerlo, ya que no hay recursividad, y esto hace que la representación y el acceso sean mucho más simples.

Answer 7

public static byte[][] arrayCopy(byte[][] arr){ 
    if(arr!=null){ 
     int[][] arrCopy = new int[arr.length][] ; 
     System.arraycopy(arr, 0, arrCopy, 0, arr.length); 
     return arrCopy; 
    }else { return new int[][]{};} 
} 

Answer 8

También se puede hacer de la siguiente manera:

public static int[][] copy(int[][] src) { 
    int[][] dst = new int[src.length][]; 
    for (int i = 0; i < src.length; i++) { 
     dst[i] = Arrays.copyOf(src[i], src[i].length); 
    } 
    return dst; 
} 

Answer 9

estoy usando esta función:

public static int[][] copy(final int[][] array) { 
    if (array != null) { 
     final int[][] copy = new int[array.length][]; 

     for (int i = 0; i < array.length; i++) { 
      final int[] row = array[i]; 

      copy[i] = new int[row.length]; 
      System.arraycopy(row, 0, copy[i], 0, row.length); 
     } 

     return copy; 
    } 

    return null; 
} 

La gran ventaja de este enfoque es que también puede copiar matrices que don' t tiene el mismo número de filas, tales como:

final int[][] array = new int[][] { { 5, 3, 6 }, { 1 } }; 

Answer 10

Así es cómo puedes hacerlo mediante el uso de bucles.

public static int[][] makeCopy(int[][] array){ 
    b=new int[array.length][]; 

    for(int row=0; row<array.length; ++row){ 
     b[row]=new int[array[row].length]; 
     for(int col=0; col<b[row].length; ++col){ 
      b[row][col]=array[row][col]; 
     } 
    } 
    return b; 
}