Как глубоко скопировать неправильный 2D массив
Используя индексы ссылочного массива в качестве порядка сортировки, реализуйте логику сортировки в функции сортировки, извлекайте ключи объекта и сортируйте их в соответствии с заданным массивом и помещайте отсортированный объект в исходный массив.
var item_array = [{ "Email Address": "c", "First Name": "a", "Last Name": "b", "Permission": "Training Administrator", "Telephone": "d", "User Group": "Company Administrator" }, {"Email Address": "3", "First Name": "1", "Last Name": "2", "Permission": "6", "Telephone": "4", "User Group": "5"}];
var item_order = ["First Name", "Last Name", "Email Address", "Permission", "Telephone", "User Group"];
item_array.forEach((obj, idx, arr) => {
arr[idx] = Object.keys(obj)
.sort((a, b) => {
return item_order.indexOf(a) - item_order.indexOf(b);
})
.reduce((acc, ele)=>{acc[ele] = obj[ele]; return acc;},{});
});
console.log(item_array);
7 ответов
int[][] copy = new int[nums.length][];
for (int i = 0; i < nums.length; i++) {
copy[i] = new int[nums[i].length];
for (int j = 0; j < nums[i].length; j++) {
copy[i][j] = nums[i][j];
}
}
Можно заменить второй цикл System.arraycopy () или Arrays.copyOf ().
Я записал это в Eclipse, протестировал его, возвратился и нашел, что João победил меня к почти точно тому же решению. Я upvoted его, но здесь является моим для сравнения. Я предполагаю, что это поучительно, чтобы видеть, что очень небольшие люди деталей принимают решение сделать по-другому.
private static int[][] copy2d(int[][] nums) {
int[][] copy = new int[nums.length][];
for (int i = 0; i < copy.length; i++) {
int[] member = new int[nums[i].length];
System.arraycopy(nums[i], 0, member, 0, nums[i].length);
copy[i] = member;
}
return copy;
}
Для дополнительного кредита попытайтесь писать тот, который копирует n-мерный массив, где n произволен.
N-мерная глубокая копия
public class ArrayTest extends TestCase {
public void testArrays() {
Object arr = new int[][]{
{5},
{9, 4},
{1, 7, 8},
{8, 3, 2, 10}
};
Object arrCopy = copyNd(arr);
int height = Array.getLength(arr);
for (int r = 0; r < height; r++) {
Object rowOrigonal = Array.get(arr, r);
Object rowCopy = Array.get(arrCopy, r);
int width = Array.getLength(rowOrigonal);
for (int c = 0; c < width; c++) {
assertTrue(rowOrigonal.getClass().isArray());
assertTrue(rowCopy.getClass().isArray());
assertEquals(Array.get(rowOrigonal, c), Array.get(rowCopy, c));
System.out.println(Array.get(rowOrigonal, c) + ":" + Array.get(rowCopy, c));
}
}
}
public static Object copyNd(Object arr) {
if (arr.getClass().isArray()) {
int innerArrayLength = Array.getLength(arr);
Class component = arr.getClass().getComponentType();
Object newInnerArray = Array.newInstance(component, innerArrayLength);
//copy each elem of the array
for (int i = 0; i < innerArrayLength; i++) {
Object elem = copyNd(Array.get(arr, i));
Array.set(newInnerArray, i, elem);
}
return newInnerArray;
} else {
return arr;//cant deep copy an opac object??
}
}
}
Другая произвольная копия n-d. Это ужасно, и благодаря системе типов Java Вы не можете бросить результат назад к типу массива, с которого Вы запустили. Однако, это работает. Как другие комментарии говорят, используют клон () :)
public void testMultiDimArray()
{
int[][][] arr = new int[][][] {
{ {5}, {5, 6 }, {3, 3, 1} },
{ {1, 2, 3}, {4, 5 } }
};
Object[] dest = (Object[]) deepCopy(arr);
// System.out.println(Arrays.deepToString(dest));
assertTrue(Arrays.deepEquals(arr, dest));
}
public static Object deepCopy(Object src)
{
int srcLength = Array.getLength(src);
Class srcComponentType = src.getClass().getComponentType();
Object dest = Array.newInstance(srcComponentType, srcLength);
if (srcComponentType.isArray())
{
for (int i = 0; i < Array.getLength(src); i++)
Array.set(dest, i, deepCopy(Array.get(src, i)));
}
else
{
System.arraycopy(src, 0, dest, 0, srcLength);
}
return dest;
}
Некоторые люди предлагают clone () - просто для большей ясности, clone () в многомерном массиве - это всего лишь мелкий клон. . original.clone () [0] == original [0] . Но (для примитивов) вы можете использовать clone () вместо System.arraycopy () , как только вы перейдете к одномерным массивам.
Вот тот, который специализируется на глубоком клонировании int [] [] . Это также позволяет любому из int [] быть нулевым .
import java.util.*;
public class ArrayDeepCopy {
static int[][] clone(int[][] arr) {
final int L = arr.length;
int[][] clone = new int[L][];
for (int i = 0; i < clone.length; i++) {
clone[i] = (arr[i] == null) ? null : arr[i].clone();
}
return clone;
}
public static void main(String[] args) {
int[][] a = {
{ 1, },
{ 2, 3, },
null,
};
int[][] b = a.clone();
System.out.println(a[0] == b[0]); // "true", meaning shallow as expected!
b = clone(a); // this is deep clone!
System.out.println(Arrays.deepEquals(a, b)); // "true"
System.out.println(a[0] == b[0]); // "false", no longer shallow!
}
}
Вот простой удобный способ копирования двумерных массивов (совместимый с DEEP copy) :
public static char[][] cloneArray(char[][] array){
char[][] copy = new char[array.length][];
for(int i = 0 ; i < array.length ; i++){
System.arraycopy(array[i], 0, copy[i] = new char[array[i].length], 0, array[i].length);
}
return copy;
}
plz note that you simple have to change array type to anything else, like int