内存分页工具类

场景

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

工具代码

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

}

优缺

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