如何用不同大小的另一个数组中的元素填充数组?(将不存在的索引保留为零)

Question

场景1：如果主数组长度<8

声明：

int[] mainArray = new int[] { 1, 2, 3, 4, 5 } // no minimum number of elements
int[] arrayOne = new int[] { 0, 0, 0, 0, 0, 0, 0, 0 }; // must have 8 elements

我想将mainArray中的值添加到arrayOne中，将备用元素保留为零。

所需阵列：

int[] arrayOne = new int[] { 1, 2, 3, 4, 5, 0, 0, 0 }; // must have 8 elements

---

场景2：如果主阵列长度>8

声明：

int[] mainArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } // no minimum number of elements
int[] arrayOne = new int[] { 0, 0, 0, 0, 0, 0, 0, 0 }; // must have 8 elements
int[] arrayTwo = new int[] { 0, 0, 0, 0, 0, 0, 0, 0 }; // must have 8 elements

我想将mainArray中的前8个值添加到arrayOne中，然后将arrayTwo中的其余值添加，使其他索引为零(你会看到第二个数组右侧的9和10，所以arrayOne从左到右，arrayTwo从右到左。如果有arrayThree，它将再次从左到左(

所需阵列：

int[] arrayOne = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 }; // must have 8 elements
int[] arrayTwo = new int[] { 0, 0, 0, 0, 0, 0, 10, 9 }; // must have 8 elements

Answer 1

试试这个。

static int copy(int[] mainArray, int start, int[] array) {
int mainArrayLength = mainArray.length;
if (start >= mainArrayLength) return start;
int length = Math.min(mainArrayLength - start, array.length);
System.arraycopy(mainArray, start, array, 0, length);
return start + length;
}
static void reverse(int[] array) {
for (int i = 0, j = array.length - 1; i < j; ++i, --j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
static void copy(int[] mainArray, int[] arrayOne, int[] arrayTwo) {
int start = copy(mainArray, 0, arrayOne);
copy(mainArray, start, arrayTwo);
reverse(arrayTwo);
}

和

int[] mainArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] arrayOne = {0, 0, 0, 0, 0, 0, 0, 0};
int[] arrayTwo = {0, 0, 0, 0, 0, 0, 0, 0};
copy(mainArray, arrayOne, arrayTwo);
System.out.println("arrayOne = " + Arrays.toString(arrayOne));
System.out.println("arrayTwo = " + Arrays.toString(arrayTwo));

输出

arrayOne = [1, 2, 3, 4, 5, 6, 7, 8]
arrayTwo = [0, 0, 0, 0, 0, 0, 10, 9]

如果要复制到两个以上的阵列而不反转它们，请执行此操作。

static void copy(int[] mainArray, int[]... arrays) {
int start = 0;
for (int[] array : arrays)
start = copy(mainArray, start, array);
}

和

int[] mainArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
int[] arrayOne = {0, 0, 0, 0, 0};
int[] arrayTwo = {0, 0, 0, 0, 0};
int[] arrayThree = {0, 0, 0, 0, 0};
copy(mainArray, arrayOne, arrayTwo, arrayThree);
System.out.println("arrayOne = " + Arrays.toString(arrayOne));
System.out.println("arrayTwo = " + Arrays.toString(arrayTwo));
System.out.println("arrayThree = " + Arrays.toString(arrayThree));

输出

arrayOne = [1, 2, 3, 4, 5]
arrayTwo = [6, 7, 8, 9, 10]
arrayThree = [11, 12, 13, 0, 0]

Answer 2

您可以使用

Arrays.fill(arr, 0);

对于后续的数组，您可以从结束索引开始——剩余项的长度取8，得出需要填充的其他数组的数量。

Answer 3

首先，我假设您为了演示而进行了这样的数组初始化。如果没有，您可以创建任何自定义数组，如下所示：int[]arrayOne=｛n，n，n、n，n｝；(使用大括号之间用逗号分隔的任意数量的元素(

为了实现你想要做的事情，你需要使用一堆循环。这就是我解决问题的方法：

if (mainArray.length <= 8) {
for (int i = 0; i < mainArray.length; i++) {
arrayOne[i] = mainArray[i];
} // very standard loop for copying and pasting elements
} else {
int direction = 1; // 1 means left to right, -1 means right to left
int shortIndex = 0; // modified as to return back to index zero when equal to 8    
for (int i = 0; i < mainArray.length; i++) {
if (i + 1 % 8 == 0 && i != 0) { // switching directions when length 8 is reached
direction *= -1;
}
if (direction == 1) {
ArrayOne[shortIndex] = mainArray[i];
shortIndex++;
} else if (direction == -1) {
ArrayTwo[shortIndex] = mainArray[I];
shortIndex--;
}
}
}

这实际上只是我勾勒出的一个基本想法，因为我还没有真正测试过这段代码，但我希望这能让你更好地了解如何解决它。此外，这可能只有在你只需要两个数组而不是3个或更多数组的情况下才有效。

基本上，如果mainArray长度大于8，您将需要一个额外的计数器变量，以及在arrayOne达到最大值并准备转到下一个时切换条件的某种变量。当这种情况发生时，我切换条件变量(direction(，以便循环知道在数组中迭代的方向。

shortIndex是我所说的第二个计数器变量。它将跟随变量"i"，每次迭代向上计数1，直到达到索引7(与长度8相同(，然后一旦方向发生变化，它将从索引7(再次与长度8一样(开始，并从那里向下计数。

我希望这个解释不会太混乱lol

Answer 4

为此，我使用List<int[]>来存储数组。它在mainArray上迭代，并按指定顺序复制内容，直到不再留下元素为止。它交替反转列表的子列表。

mainArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14 }; // no minimum number of elements
List<int[]> arrays = new ArrayList<>();
int size = 5;
int begin = 0;
// Copy the array, rounding up to a multiple of size, filling in with 0 value.
mainArray = Arrays.copyOf(mainArray, mainArray.length + (size - (mainArray.length % size)));
// convert the mainArray to a list.  Need this to use subList and reverse.
List<Integer> vals = IntStream.of(mainArray).boxed().collect(Collectors.toList());
boolean reverse = false;
while (begin < vals.size()) {
// get the first group of numbers, going from left to right.
List<Integer> sublist = vals.subList(begin,begin+size);
// check if time to reverse the sublist.
if (reverse) {
Collections.reverse(sublist);
}
// now just copy the sublist to an array and store away.
arrays.add(sublist.stream().mapToInt(Integer::intValue).toArray());
// update state
reverse = !reverse;
begin+=size;
}

for (int[] a : arrays) {
System.out.println(Arrays.toString(a));
}

打印尺寸=5

[1, 2, 3, 4, 5]
[10, 9, 8, 7, 6]
[11, 12, 13, 14, 0]

对于尺寸=8

[1, 2, 3, 4, 5, 6, 7, 8]
[0, 0, 14, 13, 12, 11, 10, 9]

这里有另一个方法，它只使用List来返回构造的数组。它只是每隔一次迭代就更改填充方向。

public static List<int[]> fill(int[] main, int size) {
List<int[]> arrays = new ArrayList<>();
main = Arrays.copyOf(main,
main.length + (size - (main.length % size)));
int count = (main.length/size)+1;
int ainc = 0;
while (count-- > 1) {
int[] temp = new int[size];
arrays.add(temp);
boolean reverse = count % 2 == 0;
int idx = reverse ? size - 1 : 0;
int inc = reverse ? -1 : 1;

for (int i = 0; i < size; i++) {
temp[idx] = main[ainc++];
idx += inc;
}
}
return arrays;
}