Skip to content

Instantly share code, notes, and snippets.

@williamchitto
Forked from thaniaclair/Paginator.java
Created January 14, 2016 20:45
Show Gist options
  • Save williamchitto/bc863809d06681420855 to your computer and use it in GitHub Desktop.
Save williamchitto/bc863809d06681420855 to your computer and use it in GitHub Desktop.
Controlador de paginação 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;
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment