分页类。

package util.page;
import java.util.ArrayList;
import java.util.List;
public class PaginationUtil {

public static final int PAGENUMBER=1;
public static final int MAXRESULTS=10;
public static final int INTERVAL=3;
public static final int FIXEDINTERVAL=3;
public static final int SORT=0;

private int rowCount; //总结果数
private int maxResults; //每页的结果数
private int pageNumber; //当前页数

private int fixedInterval; //固定的起始结束页数
private int interval; //活动的页数
private int sort; //排序方式

private boolean end; //是否结尾
private boolean first; //是否开始

private List records; //记录

public PaginationUtil(int rowCount,int pageNumber,int maxResults){
setMaxResults(maxResults);
setRowCount(rowCount);
setPageNumber(pageNumber);
fixedInterval=FIXEDINTERVAL;
interval=INTERVAL;
sort=SORT;
}
/**
*
* @param pageNumber 页数
* @param fixedInterval 最前最后用于显示的页数
* @param interval 页数往后显示几页
* @param maxResults 每页的记录数
* @param rowCount 总记录数
* @param sort 排序
*/
public PaginationUtil(int pageNumber,int fixedInterval,int interval,int maxResults,int sort,int rowCount){
setMaxResults(maxResults);
setRowCount(rowCount);
setFixedInterval(fixedInterval);
setInterval(interval);
setSort(sort);
setPageNumber(pageNumber);
}

/**
* 设置和取得总记录数
* @return
*/
public int getRowCount() {
return rowCount;
}
public void setRowCount(int rowCount) {
this.rowCount = rowCount;
}

/**
* 设定活动页数
* @return
*/
public int getInterval() {
return interval;
}
public void setInterval(int interval) {
this.interval = interval;
}

/**
* 设定固定页数
* @return
*/
public int getFixedInterval() {
return fixedInterval;
}
public void setFixedInterval(int fixedInterval) {
this.fixedInterval = fixedInterval;
}

/**
* 用于取得第一个记录
* @return
*/
public int getFirstResult() {

int first=(pageNumber-1)*maxResults;

if(first>-1)return first;

return 0;
}

/**
* 设置和取得总记录数
* @return
*/
public int getMaxResults() {
return maxResults;
}
public void setMaxResults(int maxResults) {
this.maxResults = maxResults;
}

/**
* 用于取得当前的页数
* @return
*/
public int getPageNumber() {
return pageNumber;
}
public void setPageNumber(int pageNumber) {

if(pageNumber<1)
this.pageNumber=1;

else if(pageNumber>getPages())
this.pageNumber=getPages();

else
this.pageNumber = pageNumber;
}

/**
*
* 取得前一页
* @return
*/
public int getPrevious() {

if(pageNumber<2)
return 1;

return pageNumber-1;
}

/**
* 取得后一页
* @return
*/
public int getNext() {

if(pageNumber>=getPages())
return getPages();

return pageNumber+1;
}

/**
* 取得总页数
* @return
*/
public int getPages() {
if(rowCount%maxResults==0)return rowCount/maxResults;
return rowCount/maxResults+1;
}

/**
* 取得排序的方式
* @return
*/
public int getSort() {
return sort;
}
public void setSort(int sort) {
this.sort = sort;
}
/**
* 判断是否是最后一页和第一页
* @return
*/
public boolean isEnd() {
end=getPageNumber()>=getPages();
return end;
}
public boolean isFirst() {
first=getPageNumber()<=1;
return first;
}

/**
* 取得一个页码的索引，按照给出的固定页数和增加页数以及当前页数算出一个数组,-1代表跨过可以在表现层写"..."。
* @return
*/
public Integer[] getPageIndex() {
int pages=getPages();
if(fixedInterval>=pages){
System.out.println("-1-");
return makeArray(1,pages);
}
else if((2*fixedInterval)>=pages){
System.out.println("-2-");
return makeArray(1,pages);
}else if((pageNumber+interval)<=fixedInterval){
System.out.println("-3-");
ArrayList<Integer> result=new ArrayList<Integer>();
result.addAll(makeList(1,fixedInterval));
result.add(-1);
result.addAll(makeList(pages-fixedInterval+1,pages));
return result.toArray(new Integer[0]);
}else{
if(pageNumber>pages-fixedInterval){
System.out.println("-4-");
ArrayList<Integer> result=new ArrayList<Integer>();
result.addAll(makeList(1,fixedInterval));
result.add(-1);
result.addAll(makeList(pages-fixedInterval+1,pages));
return result.toArray(new Integer[0]);
}
if(pageNumber>fixedInterval&&pageNumber<=(pages-fixedInterval)){
System.out.println("-5-");
if((pageNumber+interval)<pages-fixedInterval+1){
System.out.println("-5-1-");
ArrayList<Integer> result=new ArrayList<Integer>();
result.addAll(makeList(1,fixedInterval));
result.add(-1);
result.addAll(makeList(pageNumber,pageNumber+interval));
result.add(-1);
result.addAll(makeList(pages-fixedInterval+1,pages));
return result.toArray(new Integer[0]);
}
else{
System.out.println("-5-2-");
ArrayList<Integer> result=new ArrayList<Integer>();
result.addAll(makeList(1,fixedInterval));
result.add(-1);
result.addAll(makeList(pageNumber,pages));
return result.toArray(new Integer[0]);
}
}
if(pageNumber<=fixedInterval){
System.out.println("-6-");
if((pageNumber+interval)>(pages-fixedInterval+1)){
System.out.println("-6-1-");
return makeArray(1,pages);
}
else{
System.out.println("-6-2-");
ArrayList<Integer> result=new ArrayList<Integer>();
result.addAll(makeList(1,fixedInterval));
result.add(-1);
result.addAll(makeList(pages-fixedInterval+1,pages));
return result.toArray(new Integer[0]);
}
}
}
return makeArray(1,pages);
}

/**
* 建立一个顺序的数组
* @param start 起始数
* @param end 结束数
* @return
*/
public static Integer[] makeArray(int start,int end){
Integer[] array=new Integer[end-start+1];
for(int i=0;i<=end-start;i++){
array=i+start;
}
return array;
}

/**
* 建立一个顺序的列表
* @param start 起始数
* @param end 结束数
* @return
*/
public static List<Integer> makeList(int start,int end){
List<Integer> list=new ArrayList<Integer>();
for(int i=0;i<=end-start;i++){
list.add(i+start);
}
return list;
}
/**
* 加入记录集
* @return
*/
public List getRecords() {
return records;
}
public void setRecords(List records) {
this.records = records;
}
/**
* 显示所有的数据。
* @return
*/
public String toString(){
return
" interval:"+getInterval()+
" fixedInterval:"+getFixedInterval()+
" pages:"+getPages()+
" pageNumber:"+getPageNumber()+
" rowCount:"+getRowCount()+
" firstResult:"+getFirstResult()+
" maxResults:"+getMaxResults()+
" previous:"+getPrevious()+
" next:"+getNext()+
" sort:"+getSort()+
" end:"+isEnd()+
" first:"+isFirst();
}


public static void main(String[] args){
PaginationUtil page=new PaginationUtil(72,1,5);

for(int i=1;i<=15;i++){
page.setPageNumber(i);
System.out.print(i+":");
for(int i1:page.getPageIndex()){
System.out.print(i1+"_");
}
System.out.println();
}
}
}