¿Cómo hago una copia profunda de una matriz 2D en Java?

Question

Acabo de recibir un bit usando .clone() en mi matriz 2d boolean, pensando que esta era una copia profunda.

¿Cómo puedo realizar una copia en profundidad de mi matriz boolean[][]?

¿Debo atravesarlo y hacer una serie de System.arraycopy 's?

Answer 1

Sí, debe iterar sobre una matriz booleana 2D para poder copiarla en profundidad. También mirar java.util.Arrays#copyOf métodos si se encuentra en Java 6.

que sugeriría el siguiente código para Java 6:

public static boolean[][] deepCopy(boolean[][] original) { 
    if (original == null) { 
     return null; 
    } 

    final boolean[][] result = new boolean[original.length][]; 
    for (int i = 0; i < original.length; i++) { 
     result[i] = Arrays.copyOf(original[i], original[i].length); 
     // For Java versions prior to Java 6 use the next: 
     // System.arraycopy(original[i], 0, result[i], 0, original[i].length); 
    } 
    return result; 
} 

Answer 2

Sí, esa es la única manera de hacerlo. Ni java.util.Arrays not commons-lang ofrecen copia profunda para matrices.

Answer 3

Soy un fanático de la utilidad Arrays. Tiene un método CopyOf que va a hacer una copia profunda de una matriz 1-D para usted, por lo que querría algo así:

//say you have boolean[][] foo; 
boolean[][] nv = new boolean[foo.length][foo[0].length]; 
for (int i = 0; i < nv.length; i++) 
    nv[i] = Arrays.copyOf(foo[i], foo[i].length); 

Answer 4

He conseguido llegar a una copia profunda gama recursiva. Parece funcionar bastante bien incluso para matrices multidimensionales con diferentes longitudes de dimensión, p.

private static final int[][][] INT_3D_ARRAY = { 
     { 
       {1} 
     }, 
     { 
       {2, 3}, 
       {4, 5} 
     }, 
     { 
       {6, 7, 8}, 
       {9, 10, 11}, 
       {12, 13, 14} 
     } 
}; 

Aquí está el método de utilidad.

@SuppressWarnings("unchecked") 
public static <T> T[] deepCopyOf(T[] array) { 

    if (0 >= array.length) return array; 

    return (T[]) deepCopyOf(
      array, 
      Array.newInstance(array[0].getClass(), array.length), 
      0); 
} 

private static Object deepCopyOf(Object array, Object copiedArray, int index) { 

    if (index >= Array.getLength(array)) return copiedArray; 

    Object element = Array.get(array, index); 

    if (element.getClass().isArray()) { 

     Array.set(copiedArray, index, deepCopyOf(
       element, 
       Array.newInstance(
         element.getClass().getComponentType(), 
         Array.getLength(element)), 
       0)); 

    } else { 

     Array.set(copiedArray, index, element); 
    } 

    return deepCopyOf(array, copiedArray, ++index); 
} 

EDIT: Actualizado el código para trabajar con matrices primitivas.

Answer 5

En Java 8 esto se puede lograr como una sola línea utilizando lambdas:

<T> T[][] deepCopy(T[][] matrix) { 
    return java.util.Arrays.stream(matrix).map(el -> el.clone()).toArray($ -> matrix.clone()); 
}