Controlador de paginação Java.

Paginator.java

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

/**
 * Controlador da paginação das listas de conteúdo.
 * @author thania.clair
 */
public class Paginator {

    private static final int FIRST_PAGE = 1;
	private static final int ITEMS_PER_PAGE_DEFAULT = 10;
	private static final int RANGE_DEFAULT = 4; 
		
	/** Total de itens a ser paginado. **/
	private long totalItens;

	/** Total de itens a serem exibidos por página. **/
	private int itemsPerPage;
	
	/** Página atual sendo exibida. **/
	private int currentPage;
	
	/** Intervalo de páginas a ser mostrado antes e depois da página atual. **/
	private int range;
	
	/** Página posterior à página atual. **/
	private int nextPage;

	/** Página anterior à página atual. **/
	private int previousPage;
	
	/** Primeira página. **/
	private int firstPage;
	
	/** Última página. **/
	private int lastPage;
	
	/** Posição inicial do lote de registros sendo exibido na página. **/
	private int firstResult;
	
	/** Posição final do lote de registros sendo exibido na página. **/
	private int lastResult;

	/** Lista das páginas que ficam à esquerda da página atual. **/
	private List<Integer> leftPages;
	
	/** Lista das páginas que ficam à direita da página atual. **/
	private List<Integer> rightPages;
	
	/**
	 * Construtor padrão, com as configurações padrão.
	 */
	public Paginator() {
		this.currentPage = FIRST_PAGE;
		this.itemsPerPage = ITEMS_PER_PAGE_DEFAULT;
		this.range = RANGE_DEFAULT;
	}
	
	/**
	 * Inicializa o paginador com o total de itens real e a URL para troca de página. 
	 * @param totalItens total de itens 
	 * @param url URL para redirecionamento na troca de página.
	 */
	public void init(Long totalItens) {
		if (totalItens == null) this.totalItens = 0L;
		else this.totalItens = totalItens;
	}
	
	/**
	 * Inicializa o paginador com o total de itens real e a URL para troca de página. 
	 * @param totalItens total de itens real. 
	 * @param itemsPerPage total de itens a serem exibidos em cada página.
	 * @param url URL para redirecionamento na troca de página.
	 */
	public void init(Long totalItens, int itemsPerPage) {
		init(totalItens);
		assertArgument(itemsPerPage > 0, "O total de itens por página deve ser maior que zero.");
		this.itemsPerPage = itemsPerPage;
	}
	
	/**
	 * Calcula e carrega todas as informações necessárias para a exibição da paginação.
	 */
	public void load() {
		firstPage = FIRST_PAGE;
		nextPage = calculateNextPage();
		previousPage = calculatePreviousPage();
		lastPage = calculateLastPage();
		firstResult = calculateFirstResult();
		lastResult = calculateLastResult();
		leftPages = calculateLeftPages();
		rightPages = calculateRightPages();
	}
	
	/**
	 * Verifica se existe uma página anterior.
	 * @return <code>true</code> se tem página anterior, <code>false</code> caso contrário.
	 */
	public boolean hasPreviousPage() {
		return currentPage > firstPage;
	}
	
	/**
	 * Verifica se existe uma página posterior.
	 * @return <code>true</code> se tem página posterior, <code>false</code> caso contrário.
	 */
	public boolean hasNextPage() {
		return currentPage < lastPage;
	}
	
	/**
	 * Verifica se existem páginas à esquerda ocultas. Isto é, verifica se ainda existem mais páginas
	 * à esquerda fora do intervalo definido para exibição.
	 * @return <code>true</code> se existem páginas à esquerda ocultas, <code>false</code> caso contrário.
	 */
	public boolean hasHiddenLeftPages() {
		return currentPage > (range + 1);
	}

	/**
	 * Verifica se existem páginas à direita ocultas. Isto é, verifica se ainda existem mais páginas
	 * à direita fora do intervalo definido para exibição.
	 * @return <code>true</code> se existem páginas à direita ocultas, <code>false</code> caso contrário.
	 */
	public boolean hasHiddenRightPages() {
		return currentPage < (lastPage - range);
	}

	/**
	 * Calcula a próxima página.
	 * @return a próxima página.
	 */
	private int calculateNextPage() {
		return currentPage + 1;
	}

	/**
	 * Calcula a página anterior.
	 * @return a página anterior.
	 */
	private int calculatePreviousPage() {
		return currentPage - 1;
	}
	
	/**
	 * Calcula a última página.
	 * @return calcula a última página.
	 */
	private int calculateLastPage() {
		if (totalItens == 0L) return 0;
		int residue = (int) totalItens % itemsPerPage;
		int result = (int) totalItens / itemsPerPage;
		if (residue == 0L) return result;
		return result + 1;
	}
	
	/**
	 * Calcula o primeiro registro do lote a ser exibido.
	 * @return o primeiro resultado.
	 */
	private int calculateFirstResult() {
		if (currentPage == firstPage) return currentPage;
		return (previousPage * itemsPerPage) + 1;
	}
	
	/**
	 * Calcula o último registro do lote a ser exibido.
	 * @return o último resultado.
	 */
	private int calculateLastResult() {
		if (totalItens == 0L) return 0;
		if (currentPage == firstPage) return itemsPerPage;
		if (currentPage == lastPage) return (int) totalItens;
		return firstResult + itemsPerPage - 1;
	}

	/**
	 * Calcula quais serão as páginas à esquerda da página atual.
	 * @return uma lista de páginas.
	 */
	private List<Integer> calculateLeftPages() {
		if (currentPage == firstPage) return new ArrayList<Integer>();
		
		List<Integer> pages = new ArrayList<Integer>();
		int pageNumber = currentPage;
		for (int i = 0; i < range; i++) {
			pageNumber--;
			if (pageNumber <= 0) break;
			pages.add(pageNumber);
		}
		Collections.reverse(pages);
		return pages;
	}

	/**
	 * Calcula quais serão as páginas à direita da página atual.
	 * @return uma lista de páginas.
	 */
	private List<Integer> calculateRightPages() {
		if (currentPage == lastPage) return new ArrayList<Integer>();

		List<Integer> pages = new ArrayList<Integer>();
		int pageNumber = currentPage;
		for (int i = 0; i < range; i++) {
			pageNumber++;
			if (pageNumber > lastPage) break;
			pages.add(pageNumber);
		}
		return pages;
	}

	public int getFirstResultAsIndex() {
		return firstResult - 1;
	}
	
	public long getTotalItens() {
		return totalItens;
	}

	public void setTotalItens(long totalItens) {
		this.totalItens = totalItens;
	}

	public int getCurrentPage() {
		return currentPage;
	}

	public void setCurrentPage(int currentPage) {
		this.currentPage = currentPage;
	}

	public int getItemsPerPage() {
		return itemsPerPage;
	}

	public void setItemsPerPage(int itemsPerPage) {
		this.itemsPerPage = itemsPerPage;
	}

	public int getRange() {
		return range;
	}

	public void setRange(int range) {
		this.range = range;
	}
	
	public int getNextPage() {
		return nextPage;
	}
	
	public void setNextPage(int nextPage) {
		this.nextPage = nextPage;
	}
	
	public int getPreviousPage() {
		return previousPage;
	}
	
	public void setPreviousPage(int previousPage) {
		this.previousPage = previousPage;
	}
	
	public void setFirstPage(int firstPage) {
		this.firstPage = firstPage;
	}

	public int getFirstPage() {
		return firstPage;
	}
	
	public void setLastPage(int lastPage) {
		this.lastPage = lastPage;
	}
	
	public int getLastPage() {
		return lastPage;
	}
	
	public void setFirstResult(int firstResult) {
		this.firstResult = firstResult;
	}
	
	public int getFirstResult() {
		return firstResult;
	}
	
	public void setLastResult(int lastResult) {
		this.lastResult = lastResult;
	}
	
	public int getLastResult() {
		return lastResult;
	}
	
	public void setLeftPages(List<Integer> leftPages) {
		this.leftPages = leftPages;
	}

	public List<Integer> getLeftPages() {
		return leftPages;
	}

	public void setRightPages(List<Integer> rightPages) {
		this.rightPages = rightPages;
	}
	
	public List<Integer> getRightPages() {
		return rightPages;
	}
	
	public int getMaxResults() {
		return itemsPerPage;
	}
}