Làm cách nào để tạo bản sao sâu của mảng 2d trong Java?

Question

Tôi chỉ có chút bằng cách sử dụng .clone() trên mảng 2d boolean 2 của tôi, nghĩ rằng đây là một bản sao sâu.

Tôi làm cách nào để thực hiện bản sao sâu của mảng boolean[][]?

Tôi có nên lặp qua nó và thực hiện một loạt các System.arraycopy không?

Answer 1

Có, bạn nên lặp qua mảng boolean 2D để sao chép sâu nó. Ngoài ra nhìn vào java.util.Arrays#copyOf phương pháp nếu bạn đang ở trên Java 6.

tôi sẽ đề nghị các mã tiếp theo cho 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

Vâng, đó là cách duy nhất để làm điều đó. Không phải java.util.Arrays không phải commons-lang cung cấp bản sao sâu cho mảng.

Answer 3

Tôi là người hâm mộ tiện ích Arrays. Nó có một phương pháp copyOf rằng sẽ làm một bản sao sâu sắc về một mảng 1-D cho bạn, vì vậy bạn muốn một cái gì đó như thế này:

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

tôi đã quản lý để đưa ra một bản sao sâu mảng đệ quy. Dường như nó hoạt động khá tốt ngay cả đối với mảng đa chiều với độ dài thứ nguyên khác nhau, ví dụ:

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

Đây là phương pháp tiện ích.

@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: Cập nhật mã để làm việc với mảng nguyên thủy.

Answer 5

Trong Java 8 này có thể được thực hiện như một lớp lót bằng lambdas:

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