assignment - copy array javascript

Cómo copiar profundamente una matriz 2D irregular

Question

¿Cómo puedo copiar profundamente una matriz 2D de forma irregular en Java?

Es decir.

int[][] nums = {{5},
{9,4},
{1,7,8},
{8,3,2,10}}

No puedo usar Arrays.arrayCopy() por alguna razón (control de versiones?)

Answer 1

Copia profunda N-dimensional

public class ArrayTest extends TestCase {
public void testArrays() {
Object arr = new int[][]{
{5},
{9, 4},
{1, 7, 8},
{8, 3, 2, 10}
};
Object arrCopy = copyNd(arr);
int height = Array.getLength(arr);
for (int r = 0; r < height; r++) {
Object rowOrigonal = Array.get(arr, r);
Object rowCopy = Array.get(arrCopy, r);
int width = Array.getLength(rowOrigonal);
for (int c = 0; c < width; c++) {
assertTrue(rowOrigonal.getClass().isArray());
assertTrue(rowCopy.getClass().isArray());
assertEquals(Array.get(rowOrigonal, c), Array.get(rowCopy, c));
System.out.println(Array.get(rowOrigonal, c) + ":" + Array.get(rowCopy, c));
}
}
}
public static Object copyNd(Object arr) {
if (arr.getClass().isArray()) {
int innerArrayLength = Array.getLength(arr);
Class component = arr.getClass().getComponentType();
Object newInnerArray = Array.newInstance(component, innerArrayLength);
//copy each elem of the array
for (int i = 0; i < innerArrayLength; i++) {
Object elem = copyNd(Array.get(arr, i));
Array.set(newInnerArray, i, elem);
}
return newInnerArray;
} else {
return arr;//cant deep copy an opac object??
}
}
}

Answer 2

Escribí esto en Eclipse, lo probé, volví y descubrí que João me había vencido casi exactamente en la misma solución. Le gané, pero aquí está el mío para comparar. Supongo que es instructivo ver los pequeños detalles que las personas eligen hacer de manera diferente.

private static int[][] copy2d(int[][] nums) {
int[][] copy = new int[nums.length][];
for (int i = 0; i < copy.length; i++) {
int[] member = new int[nums[i].length];
System.arraycopy(nums[i], 0, member, 0, nums[i].length);
copy[i] = member;
}
return copy;
}

Para obtener más crédito, intente escribir uno que copie una matriz n-dimensional donde n es arbitrario.

Answer 3

int[][] copy = new int[nums.length][];
for (int i = 0; i < nums.length; i++) {
copy[i] = new int[nums[i].length];
for (int j = 0; j < nums[i].length; j++) {
copy[i][j] = nums[i][j];
}
}

Puede reemplazar el segundo ciclo con System.arraycopy () o Arrays.copyOf ().

Answer 4

Otra copia arbitraria y n. Es feo, y gracias al sistema de tipos de Java no puedes convertir el resultado al tipo de matriz con el que comenzaste. Aún así, funciona. Como los otros comentarios dicen, use clone () :)

public void testMultiDimArray()
{
int[][][] arr = new int[][][] {
{ {5}, {5, 6 }, {3, 3, 1} },
{ {1, 2, 3}, {4, 5 } }
};
Object[] dest = (Object[]) deepCopy(arr);
// System.out.println(Arrays.deepToString(dest));
assertTrue(Arrays.deepEquals(arr, dest));
}
public static Object deepCopy(Object src)
{
int srcLength = Array.getLength(src);
Class srcComponentType = src.getClass().getComponentType();
Object dest = Array.newInstance(srcComponentType, srcLength);
if (srcComponentType.isArray())
{
for (int i = 0; i < Array.getLength(src); i++)
Array.set(dest, i, deepCopy(Array.get(src, i)));
}
else
{
System.arraycopy(src, 0, dest, 0, srcLength);
}
return dest;
}

Answer 5

Algunas personas sugieren clone() : para ser más claro, clone() en una matriz multidimensional es solo un clon superficial. original.clone()[0] == original[0] . Pero (para primitivos) puede usar clone() lugar de System.arraycopy() una vez que está abajo en matrices unidimensionales.

Answer 6

Aquí hay una manera simple y conveniente de copiar matrices de dos dimensiones (compatible con la copia DEEP):

public static char[][] cloneArray(char[][] array){
char[][] copy = new char[array.length][];
for(int i = 0 ; i < array.length ; i++){
System.arraycopy(array[i], 0, copy[i] = new char[array[i].length], 0, array[i].length);
}
return copy;
}

Por favor tenga en cuenta que simplemente tiene que cambiar el tipo de matriz a cualquier otra cosa, como int

Answer 7

Aquí hay uno que se especializa en la clonación profunda int[][] . También permite que cualquiera de los int[] sea null .

import java.util.*;
public class ArrayDeepCopy {
static int[][] clone(int[][] arr) {
final int L = arr.length;
int[][] clone = new int[L][];
for (int i = 0; i < clone.length; i++) {
clone[i] = (arr[i] == null) ? null : arr[i].clone();
}
return clone;
}
public static void main(String[] args) {
int[][] a = {
{ 1, },
{ 2, 3, },
null,
};
int[][] b = a.clone();
System.out.println(a[0] == b[0]); // "true", meaning shallow as expected!
b = clone(a); // this is deep clone!
System.out.println(Arrays.deepEquals(a, b)); // "true"
System.out.println(a[0] == b[0]); // "false", no longer shallow!
}
}