Estuctura para paginar

[detective_jd]

Hola a todos, me respondo a mi mismo y pongo las versiones experimentales de mis estructuras de datos para paginar:

PagesList (actualmente está en su versión 2.8)

Código Java:

/* 
 * @author Nelson Eustaquio
 * @author Juan Diego Ocampo
 * @param <E>
 */
public class PagesList<E> implements java.util.RandomAccess, java.io.Serializable {
    public enum Navegate {
        goToFirst,
        goToPrevious,
        goToNext,
        goToLast,
        goToPresent
    }
    private final java.util.ArrayList<java.util.ArrayList<E>>paginas=new java.util.ArrayList();
    private final int limite;
    private int pagina;
    private int tamanio;
    private int ultima;
    private int filas;
    public PagesList() {
        this.limite = 12;
        this.clear();
    }
    public PagesList(int xlimite) {
        this.limite = xlimite;
        this.clear();
    }
    private java.util.ArrayList<E> getNext() {
        return (pagina == ultima) ? getLast() : paginas.get(++pagina);
    }
    private java.util.ArrayList<E> getPrevious() {
        return (pagina == 0) ? getFirst() : paginas.get(--pagina);
    }
    private java.util.ArrayList<E> getFirst() {
        return (pagina != 0) ? paginas.get((pagina = 0)) : paginas.get((pagina = 0));
    }
    private java.util.ArrayList<E> getLast() {
        return (pagina != ultima) ? paginas.get((pagina = ultima)) : paginas.get((pagina = ultima));
    }
    private java.util.ArrayList<E> getActually() {
        return paginas.get(pagina);
    }
    public java.util.ArrayList<E> getReloadPage(Navegate opcion) {
        switch (opcion) {
            case goToFirst:
                getFirst();
                break;
            case goToPrevious:
                getPrevious();
                break;
            case goToNext:
                getNext();
                break;
            case goToLast:
                getLast();
                break;
        }
        return getActually();
    }
    public synchronized void add(E objeto) throws Exception {
        if (objeto == null) {
            throw new Exception("elemento nulo");
        }
        else if (limite == filas) {
            filas = 0;
            java.util.ArrayList<E> t = new java.util.ArrayList(limite);
            paginas.add(t);
            ultima++;
            paginas.get(ultima).add(objeto);
            tamanio++;
            filas++;
        } else {
            paginas.get(ultima).add(objeto);
            filas++;
        }
    }
    public E get(int posicion) {
        return getActually().get(posicion);
    }
    public final void clear() {
        paginas.clear();
        this.pagina = 0;
        this.filas = 0;
        this.ultima=0;
        java.util.ArrayList t = new java.util.ArrayList(limite);
        paginas.add(t);
        this.tamanio = 1;
    }
    public boolean contains(Object objeto) {
        return this.indexOf(objeto) >= 0;
    }
    private int indexOf(Object objeto) {
        java.util.ArrayList<E> arreglo = this.toList();
        if (objeto == null) {
            for (int i = 0; i < arreglo.size(); i++) {
                if (arreglo.get(i) == null) {
                    return i;
                }
            }
        } else {
            for (int i = 0; i < arreglo.size(); i++) {
                if (objeto.equals(arreglo.get(i))) {
                    return i;
                }
            }
        }
        return -1;
    }
    public synchronized void remove(E objeto) {
        this.getActually().remove(objeto);
        java.util.ArrayList<E> arreglo = this.toList();
        this.clear();
        for (E obj : arreglo) {
            try {
                this.add(obj);
            } catch (Exception ex) {
                System.out.println(ex.getMessage());
            }
        }
    }
    public synchronized java.util.ArrayList<E> toList() {
        java.util.ArrayList<E> aux = new java.util.ArrayList();
        for (java.util.ArrayList<E> list : paginas) {
            for (E row : list) {
                aux.add(row);
            }
        }
        return aux;
    }
    public int size() {
        return tamanio;
    }
    public boolean isEmpty(){
        return getFirst().isEmpty();
    }
    public void sort() {
        this.sort(null);
    }
    public synchronized void sort(java.util.Comparator comp) {
        java.util.ArrayList<E> arreglo = this.toList();
        java.util.Collections.sort(arreglo, comp);
        this.clear();
        for (E obj : arreglo) {
            try {
                this.add(obj);
            } catch (Exception ex) {
                System.out.println("Error al ordenar elementos" + ex.getMessage());
            }
        }
    }
    public PagesList<E> copyTo() {
        PagesList<E> copia = new PagesList(limite);
        for (java.util.ArrayList<E> arreglo : paginas) {
            for (E obj : arreglo) {
                try {
                    copia.add(obj);
                } catch (Exception ex) {
                    System.out.println(ex.getMessage());
                }
            }
        }
        return copia;
    }
}