从现有ArrayList创建大小为N的子列表

Question

我正在学习Jjava，我在ArrayLists上发现了一个有趣的练习。目的是编写一个函数partition（），该函数接受一个参数列表和一个参数大小，并返回一个子列表列表，其中每个子列表都有最大的大小元素。

例如：

• 分区（[1，2，3，4，5]， 2） 应返回 [ [1，2]， [3，4]， [5] ]，
• 分区（[1，2，3，4，5]， 3） 应返回 [ [1，2，3]， [4，5] ]，
• 分区（[1，2，3，4，5]， 1） 应返回 [ [1]， [2]， [3]， [4]， [5] ]。

我这样做了，但只有当参数size等于1

public static void main(String[] args) {
    Apside t = new Apside();
    ArrayList<Integer> a = new ArrayList<Integer>();
    a.add(1);
    a.add(2);
    a.add(3);
    a.add(4);
    System.out.println(t.partition(a, 1));
}

public ArrayList<ArrayList> partition(ArrayList<Integer> l, int n) {
    ArrayList<ArrayList> al = new ArrayList();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < l.size(); j++) {
            for(int k =0; k<n; k++){
                ArrayList<Integer> list = new ArrayList(n);
                int b = l.get(j);
                list.add(b);
                al.add(list);
            }



        }
    }
    return al;
}




Answer 1

匿名用户

我试图理解你的解决方案，但不幸的是，我不明白。你的外部循环是错误的：最外部的循环肯定应该是从0到列表的大小，而不是分区的大小。

接下来就是你最内在的循环。每次你在里面创建一个新列表时，向其中添加一个元素，并将此列表添加到结果中。这没有任何意义。很可能你想要这样的东西（中间循环的主体）

List<Integer> list = new ArrayList<Integer>(n);
for (...) {
    ...
    int b = l.get(j);
    list.add(b);
    ...
}
al.add(list);

但是它仍然不起作用，因为你引入了第三个循环，这在这里肯定是不必要的。为了使您的解决方案可靠，您只需要两个循环(第一个是遍历整个列表，第二个是遍历当前分区:

public static List<List<Integer>> partition(List<Integer> l, int n) {
    List<List<Integer>> al = new ArrayList<>();
    for (int i = 0; i < l.size(); i += n) {
        List<Integer> list = new ArrayList<>();
        for (int j = i; j < i + n && j < l.size(); j++) {
            list.add(l.get(j));
        }
        al.add(list);
    }
    return al;
}

看看我选择的边界：外循环从0到列表的大小，以分区大小为步长，而内循环从外循环的当前索引到分区大小或列表大小，以先到者为准。

有一个简单得多的解决方案:

private static List<List<?>> partition(List<?> list, int size) {
    var result = new ArrayList<List<?>>();
    for (int i = 0; i < list.size(); i += size) {
        result.add(new ArrayList<>(list.subList(i, Math.min(i + size, list.size()))));
    }
    return result;
}

这是一种通用方法，您可以在其中传递任何元素（而不仅仅是整数）的列表并获得分区结果。这里又是一个循环，它从 0 到具有分区大小步骤的列表大小，每次都会根据分区大小获取原始列表的子列表，或者如果分区小于完整，则只获取剩余元素。

此外，作为一个旁注。看看我使用接口(< code>List)而不是实现(< code>ArrayList)并使用泛型类型(< code>ArrayList)的代码

Answer 2

您可以使用subList方法。

public ArrayList<ArrayList> partition(List<Integer> li, int n) {
    ArrayList<ArrayList> al = new ArrayList();
    int start = 0;
    int i=n;
    for(; i<li.size(); i+=n){
        List<Integer> lis = li.subList(start, i);
        ArrayList<Integer> list = new ArrayList<>();
        list.addAll(lis);
        al.add(list);
        start = i;
    }

    if(i >= li.size()){
        List<Integer> lis = li.subList(start, li.size());
        ArrayList<Integer> list = new ArrayList<>();
        list.addAll(lis);
        al.add(list);
    }
    return al;
}