内存分页工具类

发表于

场景

自定义的内存分页工具类，遇到一些麻烦的查询功能时，数据库自带的排序方法可能无法满足，此时，可以先查询并过滤所有主数据后，进行其他必要的数据处理，然后再使用内存分页返回，满足工作所需。

工具代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
java复制代码import cn.hutool.core.util.ObjectUtil;

import java.util.ArrayList;
import java.util.List;

/**
 * 内存分页工具类
 * @author laozhou
 * 2021年4月19日
 */
public class PageUtil
{
    private PageUtil()
    {
    }

    /** 默认-页码，从1开始 */
    public static final int PAGE_OFFSET = 1;

    /** 默认-页条数 */
    public static final int PAGE_SIZE = 20;

    /**
     * 重新得到处理后的页码
     * @param pageOffset 页码，从1开始
     * @return
     * 2021年4月19日
     */
    private static Integer regainPageOffset(Integer pageOffset)
    {
        pageOffset = null == pageOffset || pageOffset <= 0 ? PAGE_OFFSET : pageOffset;
        return pageOffset;
    }

    /**
     * 重新得到处理后的页条数
     * @param pageSize 页条数，大于0的整数
     * @return
     * 2021年4月19日
     */
    private static Integer regainPageSize(Integer pageSize)
    {
        pageSize = null == pageSize || pageSize <= 0 ? PAGE_SIZE : pageSize;
        return pageSize;
    }

    /**
     * 分页方法，返回所有分页的数据集合
     * @param totalList 待分页数据集合，不可为null
     * @param pageSize 页条数 [小于等于0时则置为默认值: {@link com.bwss.common.utils.PageUtil#PAGE_SIZE}]
     * @return
     * 2021年4月19日
     */
    public static <T> List<List<T>> backAllPageList(List<T> totalList, Integer pageSize)
    {
        pageSize = PageUtil.regainPageSize(pageSize);
        int totalCount = totalList.size();
        // 计算页码数
        int totalPage = totalCount / pageSize + (totalCount % pageSize == 0 ? 0 : 1);
        // 分页处理
        List<List<T>> res = new ArrayList<>(totalCount);
        for (int pageNo = 1; pageNo <= totalPage; pageNo++)
        {
            List<T> subList = PageUtil.pageList(totalList, pageNo, pageSize);
            if (ObjectUtil.isEmpty(subList))
            {
                continue;
            }
            res.add(subList);
        }

        return res;
    }

    /**
     * 分页方法，返回指定页的数据集合
     * @param totalList 待分页数据集合，不可为null
     * @param pageOffset 页码，从1开始 [小于等于0时则置为默认值: {@link com.bwss.common.utils.PageUtil#PAGE_OFFSET}]
     * @param pageSize 页条数 [小于等于0时则置为默认值: {@link com.bwss.common.utils.PageUtil#PAGE_SIZE}]
     * @return
     * 2021年4月19日
     */
    public static <T> List<T> pageList(List<T> totalList, Integer pageOffset, Integer pageSize)
    {
        pageOffset = PageUtil.regainPageOffset(pageOffset);
        pageSize = PageUtil.regainPageSize(pageSize);

        int startIndex = (pageOffset - 1) * pageSize;
        int totalCount = totalList.size();
        if (startIndex > totalCount)
        {
            return new ArrayList<>();
        }
        int endIndex = startIndex + pageSize;
        if (endIndex > totalCount)
        {
            endIndex = totalCount;
        }
        List<T> page = totalList.subList(startIndex, endIndex);

        return page;
    }

    /**
     * 使用内存分页，返回固定分页结果对象[此处为booway框架分页o]
     * @param totalList 待分页数据集合 [为 空 || null 则返回空数据分页结果对象]
     * @param pageOffset 页码，从1开始 [小于等于0时则置为默认值: {@link com.bwss.common.utils.PageUtil#PAGE_OFFSET}]
     * @param pageSize 页条数 [小于等于0时则置为默认值: {@link com.bwss.common.utils.PageUtil#PAGE_SIZE}]
     * @param queryModel 查询对象模型，可为null
     * @return
     * 2021年4月19日
     */
    /*public static <T> ResponseModel<T> backRespModelOfPage(List<T> totalList, Integer pageOffset, Integer pageSize,
            T queryModel)
    {
        ResponseModel<T> res = null;
        com.bw.framework.pagination.PageUtil pu = null;
        List<T> page = null;
        int totalCount = 0;

        if (ObjectUtil.isEmpty(totalList))
        {
            pu = new com.bw.framework.pagination.PageUtil(pageOffset, pageSize, totalCount);
            page = new ArrayList<>();
            res = new ResponseModel<T>(pu, page, queryModel);

            return res;
        }

        pageOffset = PageUtil.regainPageOffset(pageOffset);
        pageSize = PageUtil.regainPageSize(pageSize);

        totalCount = totalList.size();
        pu = new com.bw.framework.pagination.PageUtil(pageOffset, pageSize, totalCount);
        page = PageUtil.pageList(totalList, pageOffset, pageSize);
        res = new ResponseModel<T>(pu, page, queryModel);

        return res;
    }*/

}

优缺

  • 内存分页相比普通分页，更消耗内存和时间，非必要不建议使用
  • 优点是能满足一些复杂的业务需求

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%