Java 如何通过以循环方式合并3个ArrayList来创建新列表？

我有3个数组。我想合并这3个数组，并创建一个新数组来显示所有合并的整数。我希望这个新阵列是循环式的

输入示例：

array = {arr1 = 1, 2, 3, arr2 = 4, 5, 6, arr3 = 7, 8, 9}

示例输出：

arr4 = 1, 4, 7, 2, 5, 8, 3, 6, 9

我应该使用此函数，但我不明白如何使用

列表

：

字符串循环（ListofList）{

您可以更简单地使用ArrayList或Arrays进行操作。

使用数组，可以创建3个

int[]

和1个

int[][]

。 这转化为“3个

int

s数组和1个

int

数组”。这就是#4是：其他数组的数组。在代码中是：

int[]
arr1={1,2,3}，
arr2={4,5,6}，
arr3={7,8,9}；
int[]arr4={arr1，arr2，arr3}；

或者，您可以使用ArrayList，它与数组的不同之处在于您可以添加或删除元素以及其他许多操作。在本例中，逻辑是相同的，只是语法不同。您可以创建3

ArrayList

和1

ArrayList

，这将转换为“3

ArrayList

s of

Integer

s和1

ArrayList

of

ArrayList

s of

Integer

s。”在代码中是：

ArrayList
list1=新的ArrayList（Arrays.asList（1,2,3）），
list2=新的ArrayList（Arrays.asList（4,5,6）），
list3=新的ArrayList（Arrays.asList（7,8,9））；
List list4=新阵列列表
（Arrays.asList（list1、list2、list3））；

最后，您可以打印这两种方法的输出：

System.out.println（“Arrays-int[]]：”+Arrays.deepToString（arr4）
+“\n列表-列表：”+list4）；

您将获得：

Arrays - int[][]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Lists - List<List<Integer>>: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Arrays-int[]]：[[1,2,3]，[4,5,6]，[7,8,9]]
列表-列表：[[1,2,3]，[4,5,6]，[7,8,9]]

---

这有帮助吗？

您可以更简单地使用ArrayList或Arrays进行操作。

使用数组，可以创建3个

int[]

和1个

int[][]

。 这转化为“3个

int

s数组和1个

int

数组”。这就是#4是：其他数组的数组。在代码中是：

int[]
arr1={1,2,3}，
arr2={4,5,6}，
arr3={7,8,9}；
int[]arr4={arr1，arr2，arr3}；

或者，您可以使用ArrayList，它与数组的不同之处在于您可以添加或删除元素，以及其他许多操作。在本例中，逻辑是相同的，只是语法不同。您可以创建3

ArrayList

和1

ArrayList

，这将转换为“3

ArrayList

s of

Integer

s和1

ArrayList

of

ArrayList

s of

Integer

s。”在代码中：

ArrayList
list1=新的ArrayList（Arrays.asList（1,2,3）），
list2=新的ArrayList（Arrays.asList（4,5,6）），
list3=新的ArrayList（Arrays.asList（7,8,9））；
List list4=新阵列列表
（Arrays.asList（list1、list2、list3））；

最后，您可以打印这两种方法的输出：

System.out.println（“Arrays-int[]]：”+Arrays.deepToString（arr4）
+“\n列表-列表：”+list4）；

您将获得：

Arrays - int[][]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Lists - List<List<Integer>>: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Arrays-int[]]：[[1,2,3]，[4,5,6]，[7,8,9]]
列表-列表：[[1,2,3]，[4,5,6]，[7,8,9]]

---

这有帮助吗？

我认为只要循环输入并获取元素并将元素添加到数组列表中就很容易理解了

public static List<Integer> roundRobin(List<List<Integer>> listOfLists) {
    if (listOfLists == null || listOfLists.isEmpty()) {
        return new ArrayList<>();
    }

    int maxLength = -1;
    for (List<Integer> list : listOfLists) {
        if (list.size() > maxLength) {
            maxLength = list.size();
        }
    }

    List<Integer> result = new ArrayList<>(maxLength * listOfLists.size());
    for (int i = 0; i < maxLength; i++) {
        for (List<Integer> list : listOfLists) {
            if (i < list.size()) {
                result.add(list.get(i));
            }
        }
    }

    return result;

}

公共静态列表循环（列表列表）{
if（listOfLists==null | | listOfLists.isEmpty（））{
返回新的ArrayList（）；
}
int maxLength=-1；
对于（列表：ListofList）{
if（list.size（）>maxLength）{
maxLength=list.size（）；
}
}
列表结果=新的ArrayList（maxLength*ListofList.size（））；
对于（int i=0；i

我认为只需循环输入并获取元素并将元素添加到数组列表中就很容易理解了

public static List<Integer> roundRobin(List<List<Integer>> listOfLists) {
    if (listOfLists == null || listOfLists.isEmpty()) {
        return new ArrayList<>();
    }

    int maxLength = -1;
    for (List<Integer> list : listOfLists) {
        if (list.size() > maxLength) {
            maxLength = list.size();
        }
    }

    List<Integer> result = new ArrayList<>(maxLength * listOfLists.size());
    for (int i = 0; i < maxLength; i++) {
        for (List<Integer> list : listOfLists) {
            if (i < list.size()) {
                result.add(list.get(i));
            }
        }
    }

    return result;

}

公共静态列表循环（列表列表）{
if（listOfLists==null | | listOfLists.isEmpty（））{
返回新的ArrayList（）；
}
int maxLength=-1；
对于（列表：ListofList）{
if（list.size（）>maxLength）{
maxLength=list.size（）；
}
}
列表结果=新的ArrayList（maxLength*ListofList.size（））；
对于（int i=0；i

要从二维列表的列填充一维列表，可以使用两个嵌套流：先按列，然后按行。内部列表的长度无关紧要，在外部流中，可以在列仍然存在时遍历

List listOfLists=List.of(
（1,2,3,4）的列表，
第（5，6）项的列表，
（7、8、9）项的清单；
List listRobin=IntStream
//源源不断
//二维列表的列
.迭代（0，i->i+1）
//从列中获取值
//溪流
.mapToObj（i->ListofList
//迭代内部列表
.stream（）
//把那些清单放在哪里
//本栏已存在
.filter（list->list.size（）>i）
//从列中获取值
.map（list->list.get（i））
//返回新列表
.collect（收集器.toList（））
//当这些列仍然存在时
.takeWhile（list->list.size（）>0）
//变平为一条小溪
//溪流
.flatMap（列表：：流）