2009-10-14 2 views

risposta

48

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; 
} 
+0

Si noti che questo non sembra funzionare per 'Objects'. Vedi http://stackoverflow.com/questions/15135104/system-arraycopy-copies-object-or-reference-to-object – Timo

5

Sì, questo è l'unico modo per farlo. Né lo standard java.util.Arrays né i comuni-lingue offrono una copia profonda per gli array.

6

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); 
+6

Nota che questo crea solo una "copia profonda" per i tipi primitivi! Arrays.copyOf() stesso crea solo copie poco profonde. – codepleb

7

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.

+0

Questo sembra buono. A cosa si riferisce "Array"? – elgehelge

+2

Modifica: trovato da me stesso: 'import java.lang.reflect.Array;' – elgehelge

2

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()); 
} 
+1

L'uso di 'clone()' raramente è una buona idea. – Ypnypn

+2

@Ypnypn Sono totalmente d'accordo, tranne per gli array. L'uso di 'clone()' è generalmente il modo più semplice e veloce per copiare un array. – SlavaSt

+0

'clone()' per matrici è completamente soddisfacente. –

Problemi correlati