Question

我要合并两个数组的元素“依次旋转” 。

结果必须为：[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("]");

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

Answer 1

如果您要创建String类型的新组合数组，则可以在下面进行检查，请注意，数组存储的元素类型相同（对于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]

Answer 2

使用流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();

Answer 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，并以上述方法实现它。

我希望每个人都能简单而容易地理解这个答案。

结合两个数组的元素“依次”

3 个答案: