如何在Java中对二维数组进行深层复制？

Question

我只是.clone()在我的2d boolean阵列上使用,认为这是一个深层复制.

如何执行boolean[][]阵列的深层复制？

我应该循环它并做一系列System.arraycopy的吗？

Answer 1

是的,您应该迭代2D布尔数组以进行深度复制.java.util.Arrays#copyOf如果您使用的是Java 6,请查看方法.

我会建议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

在Java 8中,这可以使用lambdas作为单行完成:

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

Answer 3

我是Arrays实用程序的粉丝.它有一个copyOf方法,可以为你做一维数组的深度复制,所以你需要这样的东西:

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

我设法提出了一个递归数组深层复制.即使对于具有不同尺寸长度的多维阵列,它似乎也能很好地工作

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

这是实用方法.

@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);
}

编辑:更新了代码以使用原始数组.

Answer 5

是的,这是唯一的方法.java.util.Arrayscommons-lang 也不提供数组的深层拷贝.

Answer 6

您可以迭代该数组并执行一系列方法调用Arrays.copyOf：

boolean[][] arr1 = {{true, true}, {false, true}};    // original array
boolean[][] arr2 = Arrays.copyOf(arr1, arr1.length); // shallow copy
boolean[][] arr3 = Arrays.stream(arr1)               // deep copy
        .map(arr -> Arrays.copyOf(arr, arr.length))
        .toArray(boolean[][]::new);

arr1[0][0] = false;

System.out.println(Arrays.deepToString(arr1)); // [[false, true], [false, true]]
System.out.println(Arrays.deepToString(arr2)); // [[false, true], [false, true]]
System.out.println(Arrays.deepToString(arr3)); // [[true, true], [false, true]]

或者你可以调用Object.clone方法：

boolean[][] arr3 = Arrays.stream(arr1)
        .map(boolean[]::clone)
        .toArray(boolean[][]::new);

或者您可以为此目的创建一个通用方法：

static <T> T[][] deepCopy(T[][] matrix) {
    return Arrays.stream(matrix)
            .map(arr -> arr.clone())
            .toArray(s -> matrix.clone());
}

^{另请参阅：为什么 Array.copyOf() 在二维数组的情况下会改变原始数组？}