Java分页列表

Question

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

List A包含64元素。

List B包含33元素。

List C包含515元素。

所以总的来说，我有612元素。

例如，我想创建100元素的组(Pagination)，它看起来像这样：

第1页：List A：64元素/ List B：33元素/ List C：<代码>D23元素

第2页：List A：0元素/ List B：0元素/ List C：<代码>d33元素

第3页：List A：0元素/ List B：0元素/ List C：<代码>D43元素

第4页：List A：0元素/ List B：0元素/ List C：<代码>D53元素

第5页：List A：0元素/ List B：0元素/ List C：<代码>D63元素

第6页：List A：0元素/ List B：0元素/ List C：<代码>D73元素

第7页：List A：0元素/ List B：0元素/ List C：<代码>D83元素

我的想法是创建一个Map<Integer, List<List>，其中key是Page，value是一个包含3个代码的List (每个Lists对应一个List A、B或<Lists>D93List>)。

下面是我的代码：

            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

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

我想我走错了路，但我看不到另一种方法。

有什么想法吗？

谢谢!

最后我让它起作用了。代码如下：

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

这不起作用，因为在调用subList方法之前，我需要检查每个list包含多少个元素。

如果你不愿意检查列表的大小，这似乎才是问题所在。通过首先检查大小，使subList最多与整个列表一样大。

同样，不是

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

你应该使用

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

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

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

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

下面的代码返回一个List而不是Map，因为键是数字0，...，n，但是可以很容易地修改它以返回一个映射：

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;
}

Answer 2

一个简单的解决方案，每次创建一个全局列表(优点是它总是使用底层列表的最新版本)。

public class ListPager {

    public List<List<Object>> lists = new ArrayList<List<Object>>();

    public int _pageSize = 100;

    public void addList(List<Object> list) {
        lists.add(list);
    }

    public List<Object> getPage(int p) {
        List<Object> global = new ArrayList<Object>();
        for (List<Object> l : lists) {
            global.addAll(l);
        }
        if (p*_pageSize > global.size()) return global;
        int maxBound = (p + 1)*_pageSize;
        if (maxBound > global.size()) {
            maxBound = p*_pageSize + (global.size()%(p*_pageSize));
        }
        return global.subList(p*_pageSize, maxBound);
    }
}

关联测试类：

public class ListPagerTest {

    public static class ObjectA {
        public String toString() { return "A"; }
    }
    public static class ObjectB {
        public String toString() { return "B"; }
    }
    public static class ObjectC {
        public String toString() { return "C"; }
    }

    @Test
    public void test() {
        List<Object> listA = new ArrayList<Object>();
        for (int i = 0 ; i < 64 ; i++) { listA.add(new ObjectA()); }
        List<Object> listB = new ArrayList<Object>();
        for (int i = 0 ; i < 33 ; i++) { listB.add(new ObjectB()); }
        List<Object> listC = new ArrayList<Object>();
        for (int i = 0 ; i < 515 ; i++) { listC.add(new ObjectC()); }

        ListPager lp = new ListPager();
        lp.addList(listA);
        lp.addList(listB);
        lp.addList(listC);

        for (int i = 0 ; i < 7 ; i++) {
            System.out.println("Page " + i);
            print(lp.getPage(i));
        }
    }

    public static void print(List<Object> l) {
        StringBuffer out = new StringBuffer();
        for (Object o : l) out.append(o + ",");
        System.out.println(out.toString());
    }

}

Answer 3

您可以将所有不同的对象放在一个列表中，然后使用instanceof来检测类类型。