Java 分页列表

Question

我有 3 List不同种类的Objects 。例如:

List A包含64元素。

List B包含33元素。

List C包含515元素。

所以总共，我有 612元素。

我想对 Pagination 进行分组 ( 100 )元素，例如，它看起来像这样:

页1 :List A :64元素/List B :33元素/List C :3元素

页2 :List A :0元素/List B :0元素/List C :100元素

页3 :List A :0元素/List B :0元素/List C :100元素

页4 :List A :0元素/List B :0元素/List C :100元素

页5 :List A :0元素/List B :0元素/List C :100元素

页6 :List A :0元素/List B :0元素/List C :100元素

页7 :List A :0元素/List B :0元素/List C :12元素

我的想法是创建一个Map<Integer, List<List>其中key将是 Page和 value一个List其中包含 3 Lists (List A、B 或 C 各一个)。

这是我的代码:

            int totalPages = 0;
            int totalElements = listA.size() + listB.size() + listC.size();
            if(totalElements % PAGE_SIZE == 0) {
                totalPages = totalElements / PAGE_SIZE;
            }else {
                totalPages = (totalElements / PAGE_SIZE) + 1;
            }


            Map<Integer, List<List<ParentObject>>> paginatedMap = new HashMap<Integer, List<List<ParentObject>>>();
            for(int i=0; i<totalPages; i++) {
                List<List<ParentObject>> list = new LinkedList<List<ParentObject>>();
                List<ObjectA> subListA = new LinkedList<ObjectA>();
                List<ObjectB> subListB = new LinkedList<ObjectB>();
                List<ObjectC> subListC = new LinkedList<ObjectC>();
                int total = 0;

                if(total <= PAGE_SIZE) {
                    subListA.addAll(listA.subList(0, (PAGE_SIZE-total)-1));
                    listA.removeAll(listA.subList(0, (PAGE_SIZE-total)-1));
                    total = total + subListA.size();
                }

                if(total <= PAGE_SIZE) {
                    subListB.addAll(listB.subList(0, (PAGE_SIZE-total)-1));
                    listB.removeAll(listB.subList(0, (PAGE_SIZE-total)-1));
                    total = total + subListB.size();
                }

                if(total <= PAGE_SIZE) {
                    subListC.addAll(listC.subList(0, (PAGE_SIZE-total)-1));
                    listC.removeAll(listC.subList(0, (PAGE_SIZE-total)-1));
                    total = total + subListC.size();
                }

                list.add(subListA);
                list.add(subListB);
                list.add(subListC);
                paginatedMap.put(i, list);
            }

哪里PAGE_SIZE是 100

这不起作用，因为我当然需要检查每个元素有多少个 list在调用 subList 之前包含method .

我认为我采取了错误的方法，但我看不到其他方法。

有什么想法吗？

谢谢!

终于我让它工作了。这是代码:

private Map<Integer, List<List<MyObject>>> paginateDataRequest(List<List<MyObject>> requestLists, double pageSize) {
    Map<Integer, List<List<MyObject>>> result = new LinkedHashMap<Integer, List<List<MyObject>>>();
    int totalElements = 0;

    //We calculate the total of the elements contained in the requestLists.
    for(List<MyObject> subList : requestLists) {
        if(subList != null) {
            totalElements += subList.size();
        }
    }

    //We round it up. The result Map will contain x pages with {pageSize} elements each one. For example, if the total amount of request is 101,
    //our Map will have 2 pages (100 elements + 1 element)
    int totalRequests = (int)Math.ceil(totalElements / pageSize);

    //We iterate over each page
    for(int i=0; i<totalRequests; i++) {
        List<List<MyObject>> entry = new LinkedList<List<MyObject>>();

        int freeElements = (int)pageSize;

        for(List<MyObject> list : requestLists) {
            List<MyObject> subList = new LinkedList<MyObject>();
            if(freeElements > 0) {
                if(list.size() > freeElements) {
                    subList.addAll(list.subList(0, freeElements));
                }else {
                    subList.addAll(list);
                }
                //We update the left free elements
                freeElements -= subList.size();
            }
            entry.add(subList);
            list.removeAll(subList);

        }
        //We add a new page to the result Map
        result.put(i, entry);
    }

    return result;
}

感谢大家的帮助!

Answer 1

That's not working because of course I need to check how many elements each list contains before calling the subList method.

如果您不愿意检查列表的大小，这似乎只是问题所在。首先检查大小，使子列表最多与整个列表一样大...

也可以代替

listB.removeAll(listB.subList(0, (PAGE_SIZE-total)-1));

你应该使用

listB.subList(0, (PAGE_SIZE-total)-1).clear();

防止相等的元素被意外删除。

下面的方法提供了一种更可重用的方法来完成任务，因为它不依赖于特定数量的列表，也不会修改源列表:

将输入数据结构从 3 个单独的 List 转换为包含这些列表的列表。这允许您跟踪要从中获取元素的列表的索引以及此列表中尚未使用的元素的第一个索引。这样您就可以简单地浏览列表并添加项目，直到页面填满。

以下代码返回一个 List 而不是 Map，因为键是数字 0、...、n，但可以轻松修改为返回 map :

public static <T> List<List<List<T>>> paginate(List<? extends List<? extends T>> objects, final int pageSize) {
    List<List<List<T>>> result = new ArrayList<>();

    int index = 0;
    int size = objects.size();

    // skip empty lists
    while (index < size && objects.get(index).isEmpty()) {
        index++;
    }

    for (int pageIndex = 0; index < size;) {
        int remaining = pageSize;
        List<List<T>> page = new ArrayList<>(size);
        result.add(page);
        for (int i = 0; i < index; i++) {
            page.add(Collections.emptyList());
        }
        while (remaining > 0 && index < size) {
            List<? extends T> source = objects.get(index);
            int lastIndex = Math.min(source.size(), pageIndex + remaining);
            List<T> list = new ArrayList<>(source.subList(pageIndex, lastIndex));
            page.add(list);
            remaining -= lastIndex - pageIndex;
            if (lastIndex == source.size()) {
                index++;
                pageIndex = 0;
                // skip empty lists
                while (index < size && objects.get(index).isEmpty()) {
                    page.add(Collections.emptyList());
                    index++;
                }
            } else {
                pageIndex = lastIndex;
            }
        }
        for (int i = page.size(); i < size; i++) {
            page.add(Collections.emptyList());
        }
    }

    return result;
}