Как смешать два массива в Java?
У меня есть некоторая Строка [] массивы, например:
['a1', 'a2']
['b1', 'b2', 'b3', 'b4']
['c1']
Как я могу смешать их, так, чтобы я добрался ['a1', 'b1', 'c1', 'a2', 'b2', 'b3', 'b4'] (0 элементов a, затем b, c, 1 элемент a, b, c и так далее)?Спасибо
Более точно полученный массив должен состоять из первого значения первого массива, затем первое значение второго массива..., первое значение последнего массива, второе значение первого массива..., второе значение последнего массива..., последнее значение самого большого массива. Если массивы не имеют того же размера, меньшие просто не принимаются во внимание.
Вот иллюстрация:
a1 a2 a3 a4
b1 b2 b3 b4 b5 b6 b7
c1 c2
d1 d2 d3 d4 d5
Combines into (brackets are just to highlight steps, so they really mean nothing):
(a1 b1 c1 d1) (a2 b2 c2 d2) (a3 b3 d3) (a4 b4 d4) (b5 d5) (b6) (b7)
Кроме того, я хотел бы объединить переменное количество массива, не всего 3 или 4
8 ответов
String result[] = new String[a.length+b.length+c.length];
for (int i = 0, j = 0; j < result.length; ++i) {
if (i < a.length) {
result[j++] = a[i];
}
if (i < b.length) {
result[j++] = b[i];
}
if (i < c.length) {
result[j++] = c[i];
}
}
ОБНОВЛЕНИЕ: в более общем плане
String[] merge(String[]... arrays) {
int length = 0;
for (String[] a: arrays) {
length += a.length;
}
String result[] = new String[length];
for (int i = 0, j = 0; j < length; ++i) {
for (String[] a: arrays) {
if (i < a.length) {
result[j++] = a[i];
}
}
}
return result;
}
String[] answer = new String[a.length + b.length + c.length];
int maxLength = Math.max(a.length, Math.max(b.length, c.length));
int counter = 0;
for (int i = 0; i < maxLength; i++)
{
if (i < a.length)
answer[counter++] = a[i];
if (i < b.length)
answer[counter++] = b[i];
if (i < c.length)
answer[counter++] = c[i];
}
Если я правильно вас понял, вам нужна функция, которая объединяет ваши массивы, беря 1 следующий элемент из каждого массива, если в массиве есть следующий элемент.
Вам потребуется создать дополнительный массив индексов (см. Пример), чтобы отслеживать, есть ли в массиве элементы для слияния:
int[] indexes; //should be initialized with 0's
void int[] mergeArrays(int[] ... arrays) {
int totalLength = 0;
for (int[] array : arrays) {
totalLength += array.length;
}
int[] result = new int[totalLength];
indexes = new int[arrays.length]; //array of indexes
int mergeIndex = 0;
while (mergeIndex < totalLength) {
for (int j = 0; j < arrays.length; j++) {
if (indexes[j] != -1) {
changed = true;
result[mergeIndex++] = arrays[j][indexes[j]];
indexes[j]++;
if (arrays[j].length == indexes[j]) {
indexes[j] = -1;
}
}
}
}
return result;
}
Из вашего описания (где вам нужны все 0-е элементы, затем все 1-е и т. д., и где массивы могут быть разного размера), тогда для простого для понимания метода (но не самого эффективного) я бы сделал следующее:
- создать несколько списков, каждый из которых содержит содержимое одного из массивов
- создать список для хранения конечного результата
- , непрерывно циклически перемещаясь по спискам, удаляя 0-й элемент и добавляя его в список результатов, пока ни один из списки содержат больше элементов
Вы можете избежать создания списков и работать более эффективно, просто имея массив индексов, которые сообщают вам, какой элемент у вас есть в каждом массиве, но преобразование в списки может создать проблему легче осмыслить.
ArrayList al = new ArrayList();
al.Add(array1);
al.Add(array2);
al.Add(array3);
это, вероятно, ваш лучший выбор, иначе вы столкнетесь с проблемами в стиле ArrayIndexOutOfBound. Вы, вероятно, тоже столкнетесь с этим
String[] arr0 = ["a1", "a2"];
String[] arr1 = ["b1", "b2", "b3", "b4"];
String[] arr2 = ["c1"];
int length = arr0.length + arr1.length + arr2.length;
int max = Math.max(arr0.length, Math.max(arr1.length, arr2.length));
int index = 0;
String[] result = new String[length];
for (int i=0; i<max; i++){
if (i<arr0.length)
result[index++] = arr0[i];
if (i<arr1.length)
result[index++] = arr1[i];
if (i<arr2.length)
result[index++] = arr2[i];
}
Для подобной задачи я бы, наверное, сам свернул. Я бы создал новую String [] с размером a.length + b.length + c.length , а затем использовал бы старомодный для цикл, повторяя Math.max (a.length, Math.max (b.length, c.length)) раз. Внутри цикла я бы добавил по одному элементу из каждого, проверяя индекс по длине, прежде чем делать это, чтобы избежать исключений границ.
В другом месте также было правильно указано, что вам необходимо отслеживать индекс последнего элемента, добавленного в совокупный массив.
Все приведенные выше ответы ужасны и могут быть достигнуты за 3 оператора, если повторно использовать System.arraycopy для построения массива, достаточно большого, чтобы вместить все элементы из обоих массивов. После этого используйте методы Array.sort для сортировки этого большого массива, передаваемого в Comparator. Нет необходимости писать свою собственную сортировку пузырьков / слияний, если уже существует идеальная сортировка.