Question

我有一些String []数组，例如：

['a1', 'a2']
['b1', 'b2', 'b3', 'b4']
['c1']

我如何混合它们，以便得到['a1', 'b1', 'c1', 'a2', 'b2', 'b3', 'b4']（a的0个元素，然后b，c，a，b，c的1个元素等）？感谢

更准确地说，结果数组必须包含第一个数组的第一个值，然后是第二个数组的第一个值，...，最后一个数组的第一个值，第一个数组的第二个值，.. 。，最后一个数组的第二个值，...，最大数组的最后一个值。如果数组的大小不同，那么较小的数组就不会被考虑在内。

以下是插图：

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

Answer 1

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

Answer 2

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];
}

Answer 3

对于这样的任务，我可能会自己动手。我会创建一个大小为String[]的新a.length + b.length + c.length，然后使用一个老式的for循环，迭代Math.max(a.length, Math.max(b.length, c.length))次。在循环内部，我将从每个元素中添加一个元素，在执行此操作之前测试索引以避免边界异常。

在其他地方也正确地指出，您需要跟踪添加到聚合数组的最后一项的索引。

Answer 4

如果我理解正确的话，你需要一些函数来合并你的数组，如果数组有下一个元素，则从每个数组中取出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;
}

Answer 5

从您的描述（您需要所有第0个元素，然后是所有第1个元素，以及数组可以具有不同大小的位置），然后是一个易于理解的方法（但不是最有效的）我会做以下事情：

创建多个列表，每个列表包含其中一个数组的内容
创建一个List来保存最终结果
不断循环浏览列表，删除第0个元素，并将其添加到结果列表中，直到所有列表都不包含任何元素

你可以避免创建列表并通过一系列索引来更有效地执行操作，这些索引会告诉你每个数组中你已经达到了哪个元素，但是转换为Lists可能会使问题更容易构思。

Answer 6

要从两个或多个数组中实现混合或组合数组，您需要一个空数组来保存需要组合或混合的数组。像这样：

    String[] lines1;
    String[] lines2;
    String[] combined = new String [(lines1.length+lines2.length)];

   for (int i = 0, j = 0; j < combined.length; i++) {
       if (i < lines1.length) {
           combined[j] = lines1[i];
           j++;
       }
       if (i < lines2.length) {
           combined[j] = lines2[i];
           j++;
       }
   }

你可以通过赋值给combined[j++]来缩短内部条件，因为递增是在之后开始的。

Answer 7

ArrayList al = new ArrayList();
al.Add(array1);
al.Add(array2);
al.Add(array3);

这可能是你最好的选择，否则你会遇到ArrayIndexOutOfBound风格的问题。你可能也会遇到这种方式

Answer 8

    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];
    }

Answer 9

上面的所有答案都非常糟糕，如果重用System.arraycopy来构建一个足以容纳两个数组中所有元素的数组，则可以在3个语句中实现。之后使用Array.sort方法对传入Comparator的大数组进行排序。当一个非常精细的泡泡/合并排序已经存在时，就没有必要编写自己的泡泡/合并排序。

如何在Java中混合两个数组？

9 个答案: