Como faço uma cópia profunda de uma matriz 2d em Java?

Eu acabei de usar o .clone() na minha matriz boolean 2D, pensando que esta era uma cópia profunda.

Como posso executar uma cópia boolean[][] da minha matriz boolean[][] ?

Eu deveria percorrê-lo e fazer uma série de System.arraycopy ?

Sim, você deve iterar em um array booleano 2D para copiá-lo em profundidade. Veja também os methods java.util.Arrays#copyOf se você estiver no Java 6.

Eu sugeriria o próximo código para o 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; } 

Sou fã do utilitário Arrays. Ele tem um método copyOf que fará uma cópia detalhada de uma matriz 1-D para você, então você quer algo assim:

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

Eu consegui chegar a uma cópia profunda de matriz recursiva. Parece funcionar muito bem mesmo para matrizes multidimensionais com comprimentos de dimensão variados, por exemplo

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

Aqui está o método utilitário.

 @SuppressWarnings("unchecked") public static  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: atualizado o código para trabalhar com matrizes primitivas.

Sim, essa é a única maneira de fazer isso. Nenhum java.util.Arrays não oferece commons-lang como cópia direta para matrizes.

No Java 8 isso pode ser realizado como um one-liner usando lambdas:

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

Aqui está um exemplo reflexivo usando java.lang.reflect.Array que é mais robusto e um pouco mais fácil de seguir. Esse método copia qualquer array e copia profundamente os arrays multidimensionais.

 package mcve.util; import java.lang.reflect.*; public final class Tools { private Tools() {} /** * Returns a copy of the specified array object, deeply copying * multidimensional arrays. If the specified object is null, the * return value is null. Note: if the array object has an element * type which is a reference type that is not an array type, the * elements themselves are not deep copied. This method only copies * array objects. * * @param array the array object to deep copy * @param  the type of the array to deep copy * @return a copy of the specified array object, deeply copying * multidimensional arrays, or null if the object is null * @throws IllegalArgumentException if the specified object is not * an array */ public static  T deepArrayCopy(T array) { if (array == null) return null; Class arrayType = array.getClass(); if (!arrayType.isArray()) throw new IllegalArgumentException(arrayType.toString()); int length = Array.getLength(array); Class componentType = arrayType.getComponentType(); @SuppressWarnings("unchecked") T copy = (T) Array.newInstance(componentType, length); if (componentType.isArray()) { for (int i = 0; i < length; ++i) Array.set(copy, i, deepArrayCopy(Array.get(array, i))); } else { System.arraycopy(array, 0, copy, 0, length); } return copy; } }