Java分页列表

我有3个不同类型的

对象的
列表
。
例如：

列表
一个
包含
64个
元素

列表
B
包含
33个
元素

列表
C
包含
515
元素

因此，我总共有
612个
元素

我想对
100
元素进行分组（
Pagination
），例如，它看起来像这样：

第
1
：
List
A
：
64
元素/
列表
B
：
33
元素/
列表
C
：
3
元素

页面
2
：
List
A
：
0
elements/
List
B
：
0
elements/
List
C
：
100
elements

页面
3
：
List
A
：
0
elements/
List
B
：
0
elements/
List
C
：
100
elements

页面
4
：
List
A
：
0
elements/
List
B
：
0
elements/
List
C
：
100
elements

页面
5
：
List
A

：

0

elements/

List

B

：

0

elements/

List

C

：

100

elements

页面

6

：

List

A：

0

elements/

List

B

：

0

elements/

List

C

：

100

elements

页面

7

：

List

A

：

0

元素/

List

B

：

0

元素/

列表

C

：

12

元素

---

我的想法是创建一个

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

这不起作用，因为在调用
子列表
方法之前，我当然需要检查每个
列表
包含多少元素

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

也代替

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

你应该使用

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

防止意外删除相等的元素

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

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

以下代码返回的是
列表
，而不是
映射
，因为键是数字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;
}

公共静态列表分页（列表
这不起作用，因为在调用
子列表
方法之前，我当然需要检查每个
列表
包含多少元素

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

也代替

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

你应该使用

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

防止意外删除相等的元素

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

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

以下代码返回的是
列表
，而不是
映射
，因为键是数字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;
}

publicstaticlist分页（Listnaivesolution每次构建一个全局列表（优点是它总是使用基础列表的最后一个版本）

公共类ListPager{
public List List=new ArrayList（）；
公共int_pageSize=100；
公共无效地址列表（列表）{
列表。添加（列表）；
}
公共列表获取页面（INTP）{
List global=new ArrayList（）；
对于（列表l：列表）{
全球.addAll（l）；
}
如果（p*_pageSize>global.size（））返回全局；
int maxBound=（p+1）*\u页面大小；
如果（maxBound>global.size（））{
maxBound=p*_pageSize+（global.size（）%（p*_pageSize））；
}
返回全局.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());
    }

}

公共类ListPagerTest{
公共静态类ObjectA{
公共字符串toString（）{return“A”；}
}
公共静态类ObjectB{
公共字符串toString（）{返回“B”；}
}
公共静态类ObjectC{
公共字符串toString（）{返回“C”；}
}
@试验
公开无效测试（）{
List listA=new ArrayList（）；
对于（int i=0；i<64；i++）{listA.add（new ObjectA（））；}
List listB=新的ArrayList（）；
对于（int i=0；i<33；i++）{listB.add（new ObjectB（））；}
List listC=new ArrayList（）；
对于（inti=0；i<515；i++）{listC.add（newobjectc