分页工具类

我需要一个类似于百度搜索引擎底部的分页的东西，于是我写了一个工具类

要生成这么一个分页插件，我需要用到的有：页码列表（是一个Integer[]储存显示出来的所有页码，或者是两个int，只保管第一个页码和最后一个页码）、当前页在页码列表中的位置（因为可能要高亮）、上一页的页码、下一页的页码。

可能要用到的：当前页的数据条数

这个工具类只有一个共有的构造方法，接受五个参数

public Page(List<E> list, int rowsNum, int pageNumber, int pageSize, int maxPageList)

其中list是数据，rowsNum是总数据量，pageNumber是当前页的页码，pageSize是页面所能容纳的数据的条数，maxPageList是前端分页模块所能容纳的页码的个数

import java.util.Arrays;
import java.util.List;
/**
 * 
 * @author lille 创建于 2019-3-25 上午11:46:15
 * 
 * @param <E>
 */
public class Page<E> {

    /**
     * 
     */
    private static final long serialVersionUID = -5322787339072893931L;
    /**
     * 页码列表长度，创建时指定
     */
    public Integer pageListLength = 8;
    /**
     * 总共多少元素
     */
    public Integer rowsNum;
    /**
     * 每一页的元素个数
     */
    public Integer pageSize;
    /**
     * 当前页的元素个数
     */
    public Integer thisSize;
    /**
     * 可供显示的页码列表（编号）
     */
    public Integer[] pageList;
    /**
     * 列表长度限制,插件中最多可以显示多少个页面的按钮
     */
    public Integer maxPageList;
    /**
     * 当前页在列表中的位置
     */
    public Integer point;
    /**
     * 当前页的编号
     */
    public Integer pageNumber;
    /**
     * 总共多少页
     */
    public Integer pageCount;
    /**
     * 上一页的编号,为-1时没有上一页
     */
    public Integer lastPageNumber;
    /**
     * 下一页的编号，为-1时没有下一页
     */
    public Integer nextPageNumber;
    /**
     * 首页的页码
     */
    public Integer startPageNumber = 1;
    /**
     * 末页的页码
     */
    public Integer endPageNumber;
    /**
     * 当前页的第一行在全部数据中的位置
     */
    public Integer firstLineNumber;
    /**
     * 当前页的最后一行在全部数据中的位置
     */
    public Integer lastLineNumber;
    /**
     * 被包装的数据
     */
    public List<E> data;
    /**
     * 
     * @param list
     *            数据
     * @param rowsNum
     *            总共有多少行
     * @param pageNumber
     *            当前页是第几页
     * @param pageSize
     *            每页有多少行
     * @param maxPageLise
     *            插件中最多可以显示的页码的个数
     */
    public Page(List<E> list, Integer rowsNum, Integer pageNumber, Integer pageSize, Integer maxPageList) {
        if (rowsNum == null || rowsNum < 0) {
            throw new NumberOutOfExpectException("不符合期望的数据量：" + rowsNum);
        } else if (pageSize == null || pageSize <= 0) {
            throw new NumberOutOfExpectException("不符合期望的页面大小：" + pageSize);
        } else if (maxPageList == null || maxPageList <= 0) {
            throw new NumberOutOfExpectException("不符合期望的插件容量：" + maxPageList);
        } else if (pageNumber == null || pageNumber < 0) {
            throw new NumberOutOfExpectException("不符合期望的页面位置:" + pageNumber);
        }
        this.data = list;
        this.rowsNum = rowsNum;
        this.pageNumber = pageNumber;
        this.pageSize = pageSize;
        this.maxPageList = maxPageList;
        this.ini();
    }
    /**
     * 初始化方法
     */
    private void ini() {
        // 计算总共有多少页
        pageCount = rowsNum / pageSize + (rowsNum % pageSize == 0 ? 0 : 1);
        // 末页
        endPageNumber = pageCount;
        // 确保当前页不会超出页码范围
        if (pageNumber > pageCount) {
            pageNumber = pageCount > 0 ? pageCount : 1;
        } else if (pageNumber < 1) {
            pageNumber = 1;
        }
        // 设置页码列表
        pageListLength = pageCount > maxPageList ? maxPageList : pageCount;
        pageList = new Integer[pageListLength];
        // 计算所有标签的内容以及当前页所在标签的位置
        if (pageNumber * 2 <= pageListLength) {
            for (int i = 0; i < pageListLength; i++) {
                pageList[i] = i + 1;
            }
            point = pageNumber;
        } else if ((pageCount - pageNumber) * 2 <= pageListLength) {
            for (int i = 0; i < pageListLength; i++) {
                pageList[pageListLength - i - 1] = pageCount - i;
            }
            point = pageListLength - pageCount + pageNumber;
        } else {
            point = pageListLength / 2 + (pageListLength % 2 == 0 ? 0 : 1);
            int temp = pageNumber - point + 1;
            for (int i = 0; i < pageListLength; i++) {
                pageList[i] = temp + i;
            }
        }
        // 计算当前页的条数，和首行、末行的位置
        if (pageNumber >= pageCount) {
            boolean standard = (rowsNum % pageSize == 0) && (pageNumber == pageCount);
            thisSize = standard ? pageSize : rowsNum % pageSize;
        } else {
            thisSize = pageSize;
        }
        firstLineNumber = (pageNumber - 1) * pageSize + 1;
        lastLineNumber = firstLineNumber + thisSize - 1;
        if (thisSize == 0) {
            firstLineNumber = lastLineNumber;
        }
        // 计算上一页和下一页
        if (pageNumber == pageCount) {
            nextPageNumber = -1;
        } else {
            nextPageNumber = pageNumber + 1;
        }
        if (pageNumber == 1) {
            lastPageNumber = -1;
        } else {
            lastPageNumber = pageNumber - 1;
        }
    }

    public static long getSerialversionuid() {
        return serialVersionUID;
    }
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Page [pageListLength=");
        builder.append(pageListLength);
        builder.append(", rowsNum=");
        builder.append(rowsNum);
        builder.append(", pageSize=");
        builder.append(pageSize);
        builder.append(", thisSize=");
        builder.append(thisSize);
        builder.append(", pageList=");
        builder.append(Arrays.toString(pageList));
        builder.append(", maxPageList=");
        builder.append(maxPageList);
        builder.append(", point=");
        builder.append(point);
        builder.append(", pageNumber=");
        builder.append(pageNumber);
        builder.append(", pageCount=");
        builder.append(pageCount);
        builder.append(", lastPageNumber=");
        builder.append(lastPageNumber);
        builder.append(", nextPageNumber=");
        builder.append(nextPageNumber);
        builder.append(", startPageNumber=");
        builder.append(startPageNumber);
        builder.append(", endPageNumber=");
        builder.append(endPageNumber);
        builder.append(", firstLineNumber=");
        builder.append(firstLineNumber);
        builder.append(", lastLineNumber=");
        builder.append(lastLineNumber);
        builder.append(", data=");
        builder.append(data);
        builder.append("]");
        return builder.toString();
    }
}

/**
 * 抛出该异常以示该方法接受了数字类型的参数，但是该参数的数值超出了方法的处理范围，使该方法无法以预期的方式运行。<br>
 * 示例：某个方法体中需要将参数作为除法的除数使用，但是在方法的开头对参数检查时却发现该参数的值为零。
 * <pre>
 * public methodName(Integer par) {
 *     if (par == null || par == 0) {
 *         throw new NumberOutOfExpectException("不恰当的参数par:"+par);
 *     }
 *     ...
 *     1 / par
 *     ...
 * }
 * </pre>
 * @author lille 创建于 2019-3-27 上午10:45:58
 *
 */
public class NumberOutOfExpectException extends IllegalArgumentException {
    
    /**
     * Constructs an <code>NumberOutOfExpectException</code> with no
     * detail message.
     */
    public NumberOutOfExpectException() {
        super();
    }

    /**
     * Constructs an <code>NumberOutOfExpectException</code> with the
     * specified detail message.
     *
     * @param   s   the detail message.
     */
    public NumberOutOfExpectException(String s) {
        super(s);
    }

    /**
     * Constructs a new exception with the specified detail message and
     * cause.
     *
     * <p>Note that the detail message associated with <code>cause</code> is
     * <i>not</i> automatically incorporated in this exception's detail
     * message.
     *
     * @param  message the detail message (which is saved for later retrieval
     *         by the {@link Throwable#getMessage()} method).
     * @param  cause the cause (which is saved for later retrieval by the
     *         {@link Throwable#getCause()} method).  (A <tt>null</tt> value
     *         is permitted, and indicates that the cause is nonexistent or
     *         unknown.)
     * @since 1.5
     */
    public NumberOutOfExpectException(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new exception with the specified cause and a detail
     * message of <tt>(cause==null ? null : cause.toString())</tt> (which
     * typically contains the class and detail message of <tt>cause</tt>).
     * This constructor is useful for exceptions that are little more than
     * wrappers for other throwables (for example, {@link
     * java.security.PrivilegedActionException}).
     *
     * @param  cause the cause (which is saved for later retrieval by the
     *         {@link Throwable#getCause()} method).  (A <tt>null</tt> value is
     *         permitted, and indicates that the cause is nonexistent or
     *         unknown.)
     * @since  1.5
     */
    public NumberOutOfExpectException(Throwable cause) {
        super(cause);
    }

    
    /**
     * 
     */
    private static final long serialVersionUID = 8219283616864206304L;

}

基本思路就是

根据rowsNum和pageSize算出总共会分多少页；

生成页码列表，列表长度为MIN(总页数，模块所能容纳的页码数)；（同时计算当前页在列表中的位置）

最后计算出上一页和下一页的页码，没有就是-1