“轮流”组合两个数组的元素答案

【问题标题】：combine elements of two arrays "turn by turn"“轮流”组合两个数组的元素
【发布时间】：2019-01-12 01:29:11
【问题描述】：

我想合并两个数组的元素“轮流”。

结果必须是：[a,1,b,2,c,3,d,4,e,5]

    int[] mas1 = {1,2,3,4,5};
    String[] mas2 ={"a","b","c","d","e"};

    System.out.print("[");
    for (int i = 0; i <mas1.length ; i++) {
        System.out.print(mas2[i]+","+mas1[i]+",");

    }
    System.out.println("]");

它正在工作。但是还有另一种聪明的方法来实现它吗？

【问题讨论】：

Interleave two arrays的可能重复
@Adi219 我不需要洗牌。一个接一个地排列。
欺骗不是关于洗牌，而是关于交错两个数组（这是你在这里尝试做的）。
@Adi219 这里的最终结果是打印数组的内容（或者可能生成它们的字符串），而不是按照我的理解将它们组合成一个新数组。
@JoakimDanielson 我不是 Java 专家，但我相当肯定 OP 可以打印新数组并获得所需的结果（就像在 python 中发生的那样）

标签： java arrays

【解决方案1】：

使用流 api，您可以按索引将两者 flatMap 合二为一。以下解决方案取决于两个具有相同大小的数组

int[] mas1 = {1,2,3,4,5};
String[] mas2 ={"a","b","c","d","e"};
String[] combined = IntStream.range(0, mas1.length)
        .boxed()
        .flatMap(i -> Stream.of(mas2[i], String.valueOf(mas1[i])))
        .toArray(String[]::new);

如果你想保留类型，你也可以流式传输到对象数组

Object[] combined = IntStream.range(0, mas1.length)
        .boxed()
        .flatMap(i -> Stream.of(mas2[i], mas1[i]))
        .toArray();

【讨论】：

【解决方案2】：

如果你想创建一个String 类型的新组合数组，那么你可以在下面查看，请注意 array 存储相同类型的元素（对于 Arrays 类使用：import java.util.Arrays;）

    int[] mas1 = { 1, 2, 3, 4, 5 };
    String[] mas2 = { "a", "b", "c", "d", "e" };

    String[] combinedArray = new String[mas1.length + mas2.length];

    int mas1_index = 0;
    int mas2_index = 0;

    for (int i = 0; i < combinedArray.length; i++) {

        if (i % 2 == 0&&mas2_index<mas2.length) {
                combinedArray[i] = mas2[mas2_index++];
        } else if(mas1_index <mas1.length ) {
                combinedArray[i] = Integer.toString(mas1[mas1_index++]);
        }
    }
    System.out.println(Arrays.toString(combinedArray)); // output -> [a, 1, b, 2, c, 3, d, 4, e, 5]

【讨论】：

【解决方案3】：

@Bambam 提出了一些非常好的解决方案，如果你想要的总是与 2 个相同大小的数组有关，我肯定会应用其中一个。

但是，如果您希望两个具有不同大小的数组并且独立于它们的类型，您可以使用类似于此的解决方案：

public List<String> addRecursively(int index, Object[] array1, Object[] array2, List<String> list){
    if(index < array1.length)
        list.add(String.valueOf(array1[index]));
    if(index < array2.length)
        list.add(String.valueOf(array2[index]));
    if(index >= array1.length && index >= array2.length)
        return list;

    return addRecursively(index+1, array1, array2, list);
}

以下是如何使用此方法的示例：

Integer[] arrayOfIntegers = new Integer[]{1,2,3,4,5};
String[] arrayOfStrings = new String[]{"a","b","c","d","e","f","g","h"};
List<String> unified = addRecursively(0,arrayOfStrings,arrayOfIntegers,new ArrayList<String>);

//output = a1b2c3d4e5f6g
for(String str:unified) System.out.print(str)
//output = [a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g]
System.out.println(Arrays.toString(list.toArray()));

请注意：您不能在此方法中使用原始类型。您的数组需要具有包装原始数据类型，这可以通过boxing 实现。如果你的数组已经被实例化为原始类型，你可以像这样在 Java 8 中转换它们：

int [] primitive = //some value here;
Integer[] wrapped = IntStream.of(primitive).boxed().toArray(Integer[]::new);

您绝对可以使用像this answer 中的HashMap 并在上述方法中实现它。

我希望每个人都觉得这个答案简单易懂。

【讨论】：