也show下我的分页类

http://www.iteye.com/topic/269164
都说这个类侵入性太强，无法定制，无法国际化～

发一个我写的吧，大家给提提建议：）
我一直在写Php，正式转入Java的时间不长。刚度过NullPointerException期-_-#
这个类也写得非常仓促～大家轻批呀。
还有我的类命名可能不太规范，虚心请教：）

package yourpackage;
import java.util.ArrayList;

/**
 * 分页信息
 * jdk 1.4
 * @author MoXie
 */
public class PageSet {

    private int pageSize_default = 20;                                      /* 默认单页信息数量 */

    private int currentPage_default = 1;                                    /* 默认当前页 */

    private int pageSize = 20;                                              /* 单页条目 */

    private int currentPage = 1;	                                        /* 当前页 */

    private int recordCount = 0;                                            /* 信息数量 */

    private int pageMax = 1;                                                 /* 总页数 */

    private int startRow = 0;                                               /* 起始列 */

    private int endRow = 0;                                                 /* 结束列 */

    private boolean isStartRowReckoned = false;                                 /* 起始列是否被计算 */


    /**
     * 初始化必有参数
     * @param currentPage
     * @param recordCount
     */
    public void init(int currentPage, int recordCount) {
        this.setCurrentPage(currentPage);
        this.setRecordCount(recordCount);
//        this.reckonStartRow();  /* 计算器起始列 */
//        this.reckonEndRow();
    }

    /**
     * 重新计算 页面总数 和 当前页
     */
    public void reckonAll() {
        this.reckonPageMax();   /* 计算总页数 */
        this.reckonCurrentPage(); /* 计算当前页 */
    }

    /**
     * 计算当前页页码
     */
    public void reckonCurrentPage() {
        currentPage = currentPage <= pageMax ? currentPage : pageMax;
        currentPage = currentPage > 0 ? currentPage : currentPage_default;	 /* 默认处理 */
        currentPage = Kitchen.makeObjectConver(String.valueOf(currentPage)).getInt(); // 这个转换要替换成自己的。这个String转int的规则参见Php手册。
    }

    /**
     * 获取当前页页码
     * @return
     */
    public int getCurrentPage() {
        return currentPage;
    }

    /**
     * 设置当前页页码
     * @param currentPage
     */
    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }

    /**
     * 获取默认起始页码
     * @return
     */
    public int getCurrentPage_default() {
        return currentPage_default;
    }

    /**
     * 设置默认起始页码
     * @param currentPage_default
     */
    public void setPageCurrent_default(int currentPage_default) {
        this.currentPage_default = currentPage_default;
    }

    /**
     * 计算页面总数
     */
    public void reckonPageMax() {
        boolean isRemainder = ((this.recordCount % this.pageSize) > 0);
        pageMax = Kitchen.makeObjectConver(String.valueOf(this.recordCount / this.pageSize)).getInteger().intValue();
        if (isRemainder) {
            pageMax = pageMax + 1;
        }
    }

    /**
     * 获取页面总数
     * @return
     */
    public int getPageMax() {
        return pageMax;
    }

    /**
     * 设定页面总数
     * @param pageMax
     */
    public void setPageMax(int pageMax) {
        this.pageMax = pageMax;
    }

    /**
     * 获取单页显示条数
     * @return
     */
    public int getPageSize() {
        return pageSize;
    }

    /**
     * 设置单页显示条数
     * @param pageSize
     */
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    /**
     * 获取默认页面显示信息条数
     * @return
     */
    public int getPageSize_default() {
        return pageSize_default;
    }

    /**
     * 设置默认页面显示信息条数
     * @param pageSize_default
     */
    public void setPageSize_default(int pageSize_default) {
        this.pageSize_default = pageSize_default;
    }

    /**
     * 设置总记录数
     * @return
     */
    public int getRecordCount() {
        return recordCount;
    }

    /**
     * 获取总记录数
     * @param recordCount
     */
    public void setRecordCount(int recordCount) {
        this.recordCount = recordCount;
    }

    /**
     * 计算当前页起始行行号
     */
    public void reckonStartRow() {
        this.reckonAll();
        isStartRowReckoned = true;
        int _startRow = this.pageSize * (this.currentPage - 1);
        _startRow = _startRow >= 0 ? _startRow : 0;
        _startRow = Kitchen.makeObjectConver(String.valueOf(_startRow)).getInteger().intValue();
        this.startRow = _startRow;
    }

    /**
     * 获取当前页起始行行号
     * @return
     */
    public int getStartRow() {
        this.reckonStartRow();
        return this.startRow + 1; /* attention */
    }

//    public void setStartRow(int startRow) {
//        this.startRow = startRow;
//    }
    /**
     * 计算当前页结束行行号
     */
    public void reckonEndRow() {
        if (!isStartRowReckoned) {
            this.reckonStartRow();
        }
        endRow = startRow + this.pageSize;
        endRow = endRow <= recordCount ? endRow : recordCount;
        endRow = Kitchen.makeObjectConver(String.valueOf(endRow)).getInteger().intValue();
    }

    /**
     * 获取当前页结束行行数
     * @return
     */
    public int getEndRow() {
        this.reckonEndRow();
        return endRow;
    }

//    public void setEndRow(int endRow) {
//        this.endRow = endRow;
//    }
    /**
     * 获取第一页页码
     * @return 1
     */
    public int getFirstPage() {
        return 1;
    }

    /**
     * 获取前一页页码
     * @return
     */
    public int getPrePage() {
        int prePage = this.currentPage - 1;
        prePage = (prePage >= 1) ? prePage : 1;
        return prePage;
    }

    /**
     * 获取下一页页码
     * @return
     */
    public int getNextPage() {
        int nextPage = this.currentPage + 1;
        nextPage = (nextPage < this.pageMax) ? nextPage : this.pageMax;
        return nextPage;
    }

    /**
     * 获取最后页页码
     * @see #getPageMax() 
     * @return
     */
    public int getLastPage() {
        return this.pageMax;
    }

    /**
     * 获取所有页面列表
     * @return
     */
    public ArrayList getPageList() {
        if (!this.isStartRowReckoned) {
            this.reckonAll();
        }
        ArrayList pageList = new ArrayList();
        for (int i = 1; i <= this.pageMax; i++) {
            pageList.add(String.valueOf(i));
        }
        return pageList;
    }

    /**
     * 获取临近页面列表
     * 应急写的，还有很多需要改善的地方
     * @param count
     * @return
     */
    public ArrayList getPageList(int count) {
        if (!this.isStartRowReckoned) {
            this.reckonAll();
        }
        ArrayList pageList = new ArrayList();
        count = ((count % 2) > 0) ? count + 1 : count; /* 轉化為偶數 */
        int minPage = this.currentPage - (count / 2);
        int startPage = minPage;
        int endPage = count + startPage;
        int jumper = 0;
        boolean isBreak = true;
//        int distance = 0;
        // 雙向逼近
        do {
            jumper++;
            isBreak = true;
            /**
             * 向后走 1 位
             */
            if (startPage < 1) {
                startPage++;
                if (endPage < pageMax) {
                    endPage++;
                }
                isBreak = false;
            }
            /**
             * 向前走 1 位
             */
            if (endPage > pageMax) {
                endPage--;
                if (startPage > 1) {
                    startPage--;
                }
                isBreak = false;
            }
            if (jumper > RuntimeConstants.jumper) {
                isBreak = true;
            }
        } while (!isBreak);
        for (int i = startPage; i <= endPage; i++) {
            pageList.add(Integer.toString(i));
        }
        return pageList;
    }

    /**
     * 对比页面索引和当前页并显示相应内容
     * @param index
     * @param show
     * @param elseShow
     * @return
     */
    public String compare(int index, String show, String elseShow) {
        if (this.currentPage != index) {
            show = elseShow;
        }
        return show;
    }
}

自己研究的还是网上搜搜的..貌似看过...
跟你的差不多..少了写方法..这个不是分页..
就是个javabean...

下次请把 页面 和 数据库的东西都 写出来才是一个完整的分页...

hibernate 的 setFirest.setMax方法可以实现分页数据查询..

然后在页面显示就可以了...
学j2ee从struts学起..现在是ssh.

http://code.google.com/p/zoeey/

是这里面的，最新版本我还没放上去。
是从我的Php框架移植过来的，改了一些东西，比如计算临近页面的方法。
应为和其他工程并在一起怕版本冲突就没放SVN。
setFirst 和 setMax 所需要的值就是这个计算出来的，使用最原始的数据。
分页为什么要包含数据库呢？这并没有必然联系吧。

int _startRow = this.pageSize * (this.currentPage - 1); 
         _startRow = _startRow >= 0 ? _startRow : 0; 
         _startRow = Kitchen.makeObjectConver(String.valueOf(_startRow)).getInteger().intValue(); 


这个_startRow的写法....java人看着很头疼

不要乱批评啊，还是不错的了。

还是不错的！

我也写了个。。在我blog 上。。我结合了ssh2 再加上baseDao类来写。。

我觉得用Hibernate来控制数据会舒服点

package org.springside.modules.orm;

import java.util.Collections;
import java.util.List;

import org.apache.commons.lang.StringUtils;

/**
 * 与具体ORM实现无关的分页参数及查询结果封装.
 * 
 * @param <T> Page中记录的类型.
 * @author calvin
 */
public class Page<T> {
	// 公共变量
	public static final String ASC = "asc";
	public static final String DESC = "desc";

	public static final int MIN_PAGESIZE = 5;
	public static final int MAX_PAGESIZE = 200;

	//分页参数
	protected int pageNo = 1;
	protected int pageSize = MIN_PAGESIZE;
	protected String orderBy = null;
	protected String order = null;
	protected boolean autoCount = true;

	//返回结果
	protected List<T> result = Collections.emptyList();
	protected int totalCount = -1;

	// 构造函数

	public Page() {
		super();
	}

	public Page(final int pageSize) {
		setPageSize(pageSize);
	}

	public Page(final int pageSize, final boolean autoCount) {
		setPageSize(pageSize);
		this.autoCount = autoCount;
	}

	//查询参数函数

	/**
	 * 获得当前页的页号,序号从1开始,默认为1.
	 */
	public int getPageNo() {
		return pageNo;
	}

	/**
	 * 设置当前页的页号,序号从1开始,低于1时自动调整为1.
	 */
	public void setPageNo(final int pageNo) {
		this.pageNo = pageNo;

		if (pageNo < 1) {
			this.pageNo = 1;
		}
	}

	/**
	 * 获得每页的记录数量,默认为10.
	 */
	public int getPageSize() {
		return pageSize;
	}

	/**
	 * 设置每页的记录数量,超出MIN_PAGESIZE与MAX_PAGESIZE范围时会自动调整.
	 */
	public void setPageSize(final int pageSize) {
		this.pageSize = pageSize;

		if (pageSize < MIN_PAGESIZE) {
			this.pageSize = MIN_PAGESIZE;
		}
		if (pageSize > MAX_PAGESIZE) {
			this.pageSize = MAX_PAGESIZE;
		}
	}

	/**
	* 根据pageNo和pageSize计算当前页第一条记录在总结果集中的位置,序号从0开始.
	*/
	public int getFirst() {
		return ((pageNo - 1) * pageSize);
	}

	/**
	 * 获得排序字段,无默认值.多个排序字段时用','分隔,仅在Criterion查询时有效.
	 */
	public String getOrderBy() {
		return orderBy;
	}

	/**
	 * 设置排序字段.多个排序字段时用','分隔.仅在Criterion查询时有效.
	 */
	public void setOrderBy(final String orderBy) {
		this.orderBy = orderBy;
	}

	/**
	 * 是否已设置排序字段,仅在Criterion查询时有效.
	 */
	public boolean isOrderBySetted() {
		return StringUtils.isNotBlank(orderBy);
	}

	/**
	 * 获得排序方向,默认为asc,仅在Criterion查询时有效.
	 * 
	 * @param order 可选值为desc或asc,多个排序字段时用','分隔.
	 */
	public String getOrder() {
		return order;
	}

	/**
	 * 设置排序方式向,仅在Criterion查询时有效.
	 * 
	 * @param order 可选值为desc或asc,多个排序字段时用','分隔.
	 */
	public void setOrder(final String order) {
		//检查order字符串的合法值
		String[] orders = StringUtils.split(StringUtils.lowerCase(order), ',');
		for (String orderStr : orders) {
			if (!StringUtils.equals(DESC, orderStr) && !StringUtils.equals(ASC, orderStr))
				throw new IllegalArgumentException("排序方向" + orderStr + "不是合法值");
		}

		this.order = StringUtils.lowerCase(order);
	}

	/**
	 * 查询对象时是否自动另外执行count查询获取总记录数,默认为false,仅在Criterion查询时有效.
	 */
	public boolean isAutoCount() {
		return autoCount;
	}

	/**
	 * 查询对象时是否自动另外执行count查询获取总记录数,仅在Criterion查询时有效.
	 */
	public void setAutoCount(final boolean autoCount) {
		this.autoCount = autoCount;
	}

	// 查询结果函数

	/**
	 * 取得页内的记录列表.
	 */
	public List<T> getResult() {
		return result;
	}

	public void setResult(final List<T> result) {
		this.result = result;
	}

	/**
	 * 取得总记录数,默认值为-1.
	 */
	public int getTotalCount() {
		return totalCount;
	}

	public void setTotalCount(final int totalCount) {
		this.totalCount = totalCount;
	}

	/**
	 * 根据pageSize与totalCount计算总页数,默认值为-1.
	 */
	public int getTotalPages() {
		if (totalCount < 0)
			return -1;

		int count = totalCount / pageSize;
		if (totalCount % pageSize > 0) {
			count++;
		}
		return count;
	}

	/**
	 * 是否还有下一页.
	 */
	public boolean isHasNext() {
		return (pageNo + 1 <= getTotalPages());
	}

	/**
	 * 取得下页的页号,序号从1开始.
	 */
	public int getNextPage() {
		if (isHasNext())
			return pageNo + 1;
		else
			return pageNo;
	}

	/**
	 * 是否还有上一页. 
	 */
	public boolean isHasPre() {
		return (pageNo - 1 >= 1);
	}

	/**
	 * 取得上页的页号,序号从1开始.
	 */
	public int getPrePage() {
		if (isHasPre())
			return pageNo - 1;
		else
			return pageNo;
	}
}

这个是springside的