[英]How do I do a deep copy of a 2d array in Java?
I just got bit by using .clone()
on my 2d boolean
array, thinking that this was a deep copy.我只是在我的 2d
boolean
数组上使用.clone()
,认为这是一个深层副本。
How can I perform a deep copy of my boolean[][]
array?如何执行
boolean[][]
数组的深层复制?
Should I loop through it and do a series of System.arraycopy
's?我应该遍历它并执行一系列
System.arraycopy
吗?
Yes, you should iterate over 2D boolean array in order to deep copy it.是的,您应该遍历 2D 布尔数组以对其进行深度复制。 Also look at
java.util.Arrays#copyOf
methods if you are on Java 6.如果您使用的是 Java 6,还可以查看
java.util.Arrays#copyOf
方法。
I would suggest the next code for 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;
}
In Java 8 this can be accomplished as a one-liner using lambdas:在 Java 8 中,这可以使用 lambda 作为单行代码完成:
<T> T[][] deepCopy(T[][] matrix) {
return java.util.Arrays.stream(matrix).map(el -> el.clone()).toArray($ -> matrix.clone());
}
I'm a fan of the Arrays utility.我是 Arrays 实用程序的粉丝。 It has a copyOf method that will do a deep copy of a 1-D array for you, so you'd want something like this:
它有一个 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);
I've managed to come up with a recursive array deep copy.我设法想出了一个递归数组深拷贝。 It seems to work pretty well even for multi dimensional arrays with varying dimension lengths eg
即使对于具有不同维度长度的多维数组,它似乎也能很好地工作,例如
private static final int[][][] INT_3D_ARRAY = {
{
{1}
},
{
{2, 3},
{4, 5}
},
{
{6, 7, 8},
{9, 10, 11},
{12, 13, 14}
}
};
Here is the utility method.这是实用方法。
@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: Updated the code to work with primitive arrays.编辑:更新了代码以使用原始数组。
Yes, that's the only way to do it.是的,这是唯一的方法。 Neither
java.util.Arrays
not commons-lang offer deep copy for arrays. java.util.Arrays
commons-lang 都没有为数组提供深度复制。
You can iterate over this array and perform a series of calls of Arrays.copyOf
method:您可以遍历此数组并执行一系列
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]]
Or you can call Object.clone
method:或者你可以调用
Object.clone
方法:
boolean[][] arr3 = Arrays.stream(arr1)
.map(boolean[]::clone)
.toArray(boolean[][]::new);
Or you can create a generic method for this purpose:或者您可以为此目的创建一个通用方法:
static <T> T[][] deepCopy(T[][] matrix) {
return Arrays.stream(matrix)
.map(arr -> arr.clone())
.toArray(s -> matrix.clone());
}
See also: Why does Array.copyOf() mutate the original array in case of 2D Arrays?另请参阅:在二维数组的情况下,为什么 Array.copyOf() 会改变原始数组?
Here's a reflective example using java.lang.reflect.Array
which is more robust and a bit easier to follow.这是一个使用
java.lang.reflect.Array
的反射示例,它更健壮且更易于遵循。 This method will copy any array, and deeply copies multidimensional arrays.此方法将复制任何数组,并深度复制多维数组。
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 <T> 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> 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;
}
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.