Come si esegue una copia profonda di un array 2d in Java?

Question

Ho appena ottenuto un bit utilizzando .clone() sul mio array 2d boolean, pensando che si trattasse di una copia profonda.

Come è possibile eseguire una copia profonda del mio array boolean[][]?

Devo fare un ciclo e fare una serie di System.arraycopy?

Answer 1

Sì, dovresti scorrere su un array booleano 2D per poterlo copiare in profondità. Anche guardare java.util.Arrays#copyOf metodi se siete su Java 6.

Vorrei suggerire il codice successivo per 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ì, questo è l'unico modo per farlo. Né lo standard java.util.Arrays né i comuni-lingue offrono una copia profonda per gli array.

Answer 3

Sono un fan dell'utilità Array. Ha un metodo di copyOf che farà una copia profonda di un array di 1-D per voi, in modo che ci si vuole qualcosa di simile:

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

Sono riuscito a venire con una copia completa gamma ricorsiva. Sembra funzionare piuttosto bene anche per array multidimensionali con lunghezze di lunghezza variabile, ad es.

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

Ecco il metodo di utilità.

@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: Aggiornato il codice per lavorare con gli array primitivi.

Answer 5

In Java 8 questo può essere realizzato come un one-liner utilizzando lambda:

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