¿Cómo copio una matriz bidimensional en Java?

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 stream 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

current=old o old=current hace que las dos matrices se refieran a lo mismo, por lo que si posteriormente modificamos current , también se modificará old . Para copiar el contenido de una matriz a otra matriz, use el bucle for

 for(int i=0; i 

PD: para una matriz unidimensional, puede evitar crear su propio ciclo for usando Arrays.copyOf

 /** * 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 admitir matrices n-dimensionales de objetos ?

Debería admitir longitudes arbitrarias de matrices y comprobar si el src y el destino tienen las mismas dimensiones, y también debería copiar cada elemento de cada arreglo recursivamente , en caso de que el Objeto fuera también una matriz.

Ha pasado un tiempo desde que publiqué esto, pero encontré un buen ejemplo de una forma 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 un Object[] matriz plana subyacente 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 progtwigció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.

Lo resolví escribiendo una función simple para copiar arreglos int multidimensionales usando 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 en realidad lo mejoré para mi caso de uso:

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

También puedes hacer lo siguiente:

 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; } 
 current = old ; 

Las operaciones de asignación no copian elementos de una matriz a otra. Simplemente está haciendo que la matriz current refiera a la matriz anterior. Necesita hacer una copia sabia de miembro.

Las matrices en java son objetos y todos los objetos se pasan por referencia . Para realmente “copiar” una matriz, en lugar de crear otro nombre para una matriz, debe ir y crear una nueva matriz y copiar todos los valores. Tenga en cuenta que System.arrayCopy copiará matrices de 1 dimensión por completo, pero NO matrices de 2 dimensiones. La razón es que una matriz 2D es, de hecho, una matriz 1D de matrices 1D y copias de arrayCop sobre punteros a las mismas matrices 1D internas.

 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[][]{};} } 

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 no tienen el mismo recuento de filas, como:

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

Así es como puedes hacerlo usando bucles.

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

Puedes probar el código siguiente,

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

Espero que funcione.