Java 编写一个合并两个数组列表的方法，交替使用两个数组列表中的元素

写一个方法

公共静态ArrayList合并（ArrayList a、ArrayList b）

合并两个数组列表，交替使用两个数组列表中的元素。如果一个数组列表比另一个数组列表短，则尽可能长地替换，然后从较长的数组列表中附加其余元素。例如，如果

1 4 9 16

b是

974911

然后merge返回数组列表

11947941611

---

我尝试使用if语句编写for循环，这样当I为偶数（I%2==0）时，从数组列表a向合并数组列表添加一个数字，当I为奇数时，从数组列表b向合并数组列表添加一个数字。但是，我不知道如何处理一个数组列表可能比另一个数组列表长的事实。谁能帮我一下吗

编辑：好的，下面是代码（但远远不正确）：

publicstaticarraylistmerge（arraylisteen，arraylisttwee）
{
ArrayList merged=新的ArrayList（）；
for（inti=0；i迭代器似乎最容易做到这一点

public static <T> ArrayList<T> merge(Collection<T> a, Collection<T> b) {
    Iterator<T> itA = a.iterator();
    Iterator<T> itB = b.iterator();
    ArrayList<T> result = new ArrayList<T>();

    while (itA.hasNext() || itB.hasNext()) {
        if (itA.hasNext()) result.add(itA.next());
        if (itB.hasNext()) result.add(itB.next());
    }

    return result;
}

公共静态数组列表合并（集合a、集合b）{
迭代器itA=a.Iterator（）；
迭代器itB=b.迭代器（）；
ArrayList结果=新建ArrayList（）；
while（itA.hasNext（）| | itB.hasNext（））{
if（itA.hasNext（））result.add（itA.next（））；
如果（itB.hasNext（））结果。添加（itB.next（））；
}
返回结果；
}

没有迭代器：

public static <T> ArrayList<T> merge(List<T> a, List<T> b) {
    ArrayList<T> result = new ArrayList<T>();
    int size = Math.max(a.size(), b.size());

    for (int i = 0; i < size; i++) {
        if (i < a.size()) result.add(a.get(i));
        if (i < b.size()) result.add(b.get(i));
    }

    return result;
}

公共静态数组列表合并（列表a、列表b）{
ArrayList结果=新建ArrayList（）；
int size=Math.max（a.size（），b.size（））；
对于（int i=0；i

注意，我已经放松了方法签名。如果使用迭代器实现合并，
Collection
（甚至
Iterable
）就可以了。否则，
List
就可以了。没有迭代器，就不需要将
ArrayList
作为方法参数类型

public static ArrayList merge(ArrayList a, ArrayList b) {
    int c1 = 0, c2 = 0;
    ArrayList<Integer> res = new ArrayList<Integer>();

    while(c1 < a.size() || c2 < b.size()) {
        if(c1 < a.size())
            res.add((Integer) a.get(c1++));
        if(c2 < b.size())
            res.add((Integer) b.get(c2++));
    }
    return res;
}

公共静态ArrayList合并（ArrayList a，ArrayList b）{
int c1=0，c2=0；
ArrayList res=新的ArrayList（）；
而（c1
试试这个：我是用数组实现的

public static void main(String[] args) {
    int[] first = { 1, 4, 9, 16 };
    int[] second = { 9, 7, 4, 9, 11 };
    int[] merge = new int[first.length + second.length];
    int j = 0, k = 0, l = 0;
    int max = Math.max(first.length, second.length);
    for (int i = 0; i < max; i++) {
        if (j < first.length)
            merge[l++] = first[j++];
        if (k < second.length)
            merge[l++] = second[k++];
    }
    System.out.println(Arrays.toString(merge));
}

您不需要检查模，否则将跳过每个输入列表中的每一个元素

public static <E> List<E> merge(List<E> een, List<E> twee) {
    List<E> merged = new ArrayList<E>(een.size() + twee.size());
    List<E> shorter = een.size() <= twee.size() ? een : twee;
    List<E> longer = een.size() > twee.size() ? een : twee;
    for (int i = 0; i < shorter.size(); i++) {
        merged.add(een.get(i));
        merged.add(twee.get(i));
    }
    for (int i = shorter.size(); i < longer.size(); i++) {
        merged.add(longer.get(i));
    }
    return merged;
}

公共静态列表合并（列表een、列表twee）{
列表合并=新的数组列表（een.size（）+twee.size（））；
列表较短=een.size（）twee.size（）？een:twee；
对于（int i=0；i

此泛型版本适用于所有类型的列表和泛型类型。
试试这个

Iterator iterator1 = arr1.iterator();
     Iterator iterator2 = arr2.iterator();
     while (iterator1.hasNext() || iterator2.hasNext()) {
       if(iterator1.hasNext()){
         mergerArr.add(iterator1.next());
       }
       if(iterator2.hasNext()){
         mergerArr.add(iterator2.next());
       }
     }

这是我的解决办法

LinkedList<Integer> list3 = new LinkedList<Integer>();


Iterator<Integer> itA = list.iterator();
Iterator<Integer> itB = list2.iterator();

while(itA.hasNext() && itB.hasNext()){
    list3.add(itA.next());
    list3.add(itB.next());
}

LinkedList list3=新建LinkedList（）；
迭代器itA=list.Iterator（）；
迭代器itB=list2.Iterator（）；
while（itA.hasNext（）&&itB.hasNext（））{
列表3.add（itA.next（））；
列表3.添加（itB.next（））；
}
Array1={1,2,3}
Array2={a，b，c，d，e}

输出={1，a，2，b，3，c，d，e}

公共类合并数组
{

publicstaticvoidmain（字符串参数[]）
{
char[]arr1={'1'，'2'，'3'}；
char[]arr2={'a'，'b'，'c'，'d'，'e'}；
int l1=arr1.1长度；
int l2=arr2.5长度；
int l3=l1+l2；
char[]arr3=新字符[l1+l2]；
int i=0；
int j=0；
int k=0；
int m=0；
int r=0；
如果（l1我在php中以以下方式完成此操作：

<?php
    $list1 = array("a","b","c");
    $list2 = array(1,2,3);
    $list3 = array();
    $j=0;
    $k=0;

    for($i=0;$i<6;$i++)
    {
        if($i%2==0)
        {
            $list3[$i]=$list1[$j];
            $j++;
        }

        else
        {
            $list3[$i]=$list2[$k];
            $k++;
        }

        echo $list3[$i]."<br>";
    }
?>

好的，我的建议是使用ArrayList：

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] list1 = in.nextLine().split(",");
        String[] list2 = in.nextLine().split(",");
        ArrayList<String> merged = new ArrayList<>();
        for (int i = 0; i < Math.max(list1.length,list2.length); i++) {
                merged.add(list1[i]);
                merged.add(list2[i]);
        }
        System.out.println(String.join(",", merged));
    }

publicstaticvoidmain（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
字符串[]list1=in.nextLine（）.split（“，”）；
字符串[]list2=in.nextLine（）.split（“，”）；
ArrayList merged=新的ArrayList（）；
for（int i=0；i

如果您确定输入仅为数字，则可以将代码更改为整数。
我也遇到过同样的情况，下面是我的解决方案：

// array list to hold the merged list
ArrayList<Integer> mergedList = new ArrayList<Integer>();

// Get the bigger size
int maxSize = listOne.size() > listTwo.size() ? listOne.size() : listTwo.size();

// Loop thru the list
for( int i = 0; i <= maxSize; i++){
    // We need to check first if index exist then just add it to mergeList
    if( i < listOne.size() ) mergedList.add( listOne.get( i ) );
    // We need to check first if index exist then just add it to mergeList
    if( i < listTwo.size() ) mergedList.add( listTwo.get( i ) );
}

//保存合并列表的数组列表
ArrayList mergedList=新的ArrayList（）；
//拿大一点的
int maxSize=listOne.size（）>listwo.size（）？listOne.size（）：listwo.size（）；
//循环浏览列表
对于（inti=0；i与上面相同。并查看
List.iterator（）
好的，对不起。我只是认为代码的质量太低，不值得发布。但是，你们中的任何人都可以为我提供一种比使用列表迭代器更“基本”的方法吗？发布代码，即使质量很差，也会显示出您为解决问题所做的努力，因此您更有可能得到答案d不太可能被否决：）谢谢，但是，我认为我不应该使用“迭代器”，因为我的讲座中从未涉及到这些。我知道这可能是解决问题的最优雅的方法，但是还有更基本和更直观的方法吗？mause，你应该能够从这个例子中推断出这一点。这应该对你的装备有所帮助HT方向，即使你以前没有见过迭代器。@ MauS:我不会考虑其他方式“更基本或更直观”，但是对于记录，我增加了一个“索引访问”，谢谢你：你的答案和山姆的答案是关于我正在寻找的东西。非常感谢：。如果要将列表内容显式强制转换为
Integer
，我会将该信息提升到方法签名。您的方法看起来可以合并
ArrayList
，但这不是真的。另一方面
<?php
    $list1 = array("a","b","c");
    $list2 = array(1,2,3);
    $list3 = array();
    $j=0;
    $k=0;

    for($i=0;$i<6;$i++)
    {
        if($i%2==0)
        {
            $list3[$i]=$list1[$j];
            $j++;
        }

        else
        {
            $list3[$i]=$list2[$k];
            $k++;
        }

        echo $list3[$i]."<br>";
    }
?>

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] list1 = in.nextLine().split(",");
        String[] list2 = in.nextLine().split(",");
        ArrayList<String> merged = new ArrayList<>();
        for (int i = 0; i < Math.max(list1.length,list2.length); i++) {
                merged.add(list1[i]);
                merged.add(list2[i]);
        }
        System.out.println(String.join(",", merged));
    }

// array list to hold the merged list
ArrayList<Integer> mergedList = new ArrayList<Integer>();

// Get the bigger size
int maxSize = listOne.size() > listTwo.size() ? listOne.size() : listTwo.size();

// Loop thru the list
for( int i = 0; i <= maxSize; i++){
    // We need to check first if index exist then just add it to mergeList
    if( i < listOne.size() ) mergedList.add( listOne.get( i ) );
    // We need to check first if index exist then just add it to mergeList
    if( i < listTwo.size() ) mergedList.add( listTwo.get( i ) );
}