Question

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

List A包含64元素。

List B包含33元素。

List C包含515元素。

总的来说，我有612个元素。

我想制作Pagination元素的组（100），例如，它看起来像这样：

网页1：List A：64个元素/ List B：33个元素/ {{1} } List：C元素

网页3：2 List：A个元素/ 0 List：B个元素/ {{1} } 0：List元素

网页C：100 3：List个元素/ A 0：List个元素/ {{1} } B：0元素

网页List：C 100：4个元素/ List A：0个元素/ {{1} } List：B元素

网页0：List C：100个元素/ 5 List：A个元素/ {{1} } 0：List元素

网页B：0 List：C个元素/ 100 6：List个元素/ {{1} } A：0元素

网页List：B 0：List个元素/ C 100：7个元素/ {{1} } List：A元素

我的想法是创建0 List为B，0为List，其中包含3 C（每个12 Map<Integer, List<List>，key或Page一个。

这是我的代码：

value

List为100

这不起作用，因为我在调用Lists List之前需要检查每个A包含的元素数量。

我认为我采取了错误的方式，但我没有看到另一种方法。

有什么想法吗？

谢谢！

最后我开始工作了。这是代码：

感谢大家的帮助！

Answer 1

这不起作用，因为我在调用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

Naive解决方案每次构建一个全局列表（优先考虑它始终采用最新版本的基础列表）。

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

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

Java Paginated List

3 个答案: