修复了Java中的子列表计数，但没有动态成员

我有下面的整数列表

List<Integer> arrayList = new ArrayList<Integer>();
   for (int i = 0; i < 7; i++) {
    arrayList.add(i);
}

如果我将值=4作为参数，那么我想像这样拆分4个子列表

[0,5], [1,6] , [2], [3], [4]

[0,4], [1,5], [2,6] , [3]

[0,3,6], [1,4], [2,5]

如果我将值=3作为参数，那么我希望像这样拆分3个子列表

[0,5], [1,6] , [2], [3], [4]

[0,4], [1,5], [2,6] , [3]

[0,3,6], [1,4], [2,5]

我已经测试了以下功能，但这不是我的需要

public List<List<Integer>> chopped(List<Integer> list, final int splitCount) {
        List<List<Integer>> parts = new ArrayList<List<Integer>>();
        final int N = list.size();
        for (int i = 0; i < N; i += splitCount) {
            parts.add(new ArrayList<Notification>(list.subList(i, Math.min(N, i + splitCount))));
        }
        return parts;
    }

我期望的结果是

[0,5]、[1,6]、[2]、[3]、[4]

那么：

public List<List<Integer>> chopped(List<Integer> list, final int splitCount) {
    List<List<Integer>> parts = new ArrayList<>(splitCount);
    for (int i = 0; i < splitCount; ++i) {
        parts.add(new ArrayList<>());
    }
    final int N = list.size();
    for (int i = 0; i < N; ++i) {
        parts.get(i % splitCount).add(list.get(i));
    }
    return parts;
}

公共列表（列表列表，最终整数拆分计数）{
列表部件=新的ArrayList（拆分计数）；
对于（int i=0；i

使用无变量流的功能实现：

public static void main(String[] args) {
    List<Integer> asList = Arrays.asList(0, 1, 2, 3, 4, 5, 6);
    System.out.println(chopped(asList, 3));
}

private static List<List<Integer>> chopped(List<Integer> source, int splitCount) {
    return IntStream.range(0, splitCount)
        .boxed()
        .map(index -> getElements(source, index, splitCount))
        .collect(Collectors.toList());
}

private static List<Integer> getElements(List<Integer> source, int index, int splitCount) {
    return IntStream.range(0, source.size())
            .filter(i -> i % splitCount  == index)
            .map(i -> source.get(i))
            .boxed()
            .collect(Collectors.toList());
}

publicstaticvoidmain（字符串[]args）{
列表asList=Arrays.asList（0,1,2,3,4,5,6）；
系统输出打印LN（切碎（asList，3））；
}
私有静态列表（列表源，int splitCount）{
返回IntStream.range（0，拆分计数）
.boxed（）
.map（索引->获取元素（源、索引、拆分计数））
.collect（Collectors.toList（））；
}
私有静态列表getElements（列表源、整型索引、整型拆分计数）{
返回IntStream.range（0，source.size（））
.filter（i->i%splitCount==索引）
.map（i->source.get（i））
.boxed（）
.collect（Collectors.toList（））；
}

Simple Solution希望这有帮助

ArrayList al1=新的ArrayList（）；
ArrayList al2=新的ArrayList（）；
//在al1中添加对象。。。
int numberToSplit=2；
如果（numberToSplit>al1.size（））{
抛出新异常（“您的消息”）；
}否则{
ArrayList newArr；
int计数器=0；
对于（int j=0；j

请您指定要实施的规则，好吗？不是仅仅举个例子吗？我以为我算出了你的要求，但后来我看到了N=3的例子。@GhostCat对不起，我不明白你说的话？在我的问题中，哪些部分你不明白。对不起，我的英语不好。我是说：不要仅仅通过例子来描述你的要求。您还应该直接描述需求。我不明白如何使用“列表长度”和“分割因子”来确定预期结果。您可能想添加一个解释，说明整个主题是关于对元素进行某种“模块”分布。还有：我喜欢你的答案——简单易懂！