[SOLUCIONADO] Estuctura para paginar

[detective_jd]

Hola a todos, acá tengo una consulta es sobre paginación de registros:

la cuestión es que quiero crear una estructura de datos para paginar los datos de otra estructura de datos ya sea una lista o mapa en fin, a esas las convierto en array hasta ahí va bien pero al momento de iniciar las páginas me da este error:

Exception in thread "main" java.lang.NullPointerException
at paginacionnivel2.Cuerpo.main(Cuerpo.java:7)
Java Result: 1

aquí pongo mi código:

package paginacionnivel2;
import java.util.TreeMap;
public class TreePages<E>
{
private final TreeMap<Integer,E[]>colPaginas=new TreeMap();
private final int numPagActual;
private final E[]arreglo;
private int cantXPag;
public void setCantPaginas(int xcantXPag) {
this.cantXPag = xcantXPag;
}
public TreePages(E[] xarreglo, int xcantXPag) {
this.arreglo = xarreglo;
this.cantXPag = xcantXPag;
this.numPagActual=1;
this.iniciarPaginas();
}

public E[] next(){
E[]pagina=null;
if (colPaginas.lastKey() > numPagActual)
{
pagina=colPaginas.get(numPagActual+1);
}
return pagina;
}
public E[] previous() {
E[]pagina=null;
if (colPaginas.firstKey() < numPagActual)
{
pagina=colPaginas.get(numPagActual-1);
}
return pagina;
}
public E[] first(){
E[]pagina=null;
if (colPaginas.firstKey() != numPagActual)
{
pagina=colPaginas.get(colPaginas.firstKey());
}
return pagina;
}
public E[] last(){
E[]pagina=null;
if (colPaginas.lastKey() != numPagActual)
{
pagina=colPaginas.get(colPaginas.lastKey());
}
return pagina;
}
private void iniciarPaginas()
{
int cont=1;
int cantPAG=arreglo.length/cantXPag;
for(E objeto : arreglo)
if(cantPAG!=cont)
{
E[] temporal=(E[])new Object[cantXPag];
for(int i=0;i<cantXPag;i++)
temporal[i]=objeto;
colPaginas.put(cont, temporal);
cont++;
}
}
}

el problema esta en el método iniciarPaginas cuando empieza el for pero de ahí en adelante no se me ocurre nada de cómo resolverlo.

tengo cómo paginar mis datos pero quiero crear esta estructura de datos para q no ponga el largo del array cómo parámetro para obtener la última pagina.

aquí dejo el resto del código:

package paginacionnivel2;
import java.util.LinkedList;
public class ContrRatas
{
private static ContrRatas objgestor=null;
private LinkedList<Ratas>colratas=null;
public static ContrRatas getInstance()
{
if(objgestor==null)
{
objgestor=new ContrRatas();
}
return objgestor;
}
private ContrRatas()
{
colratas=new LinkedList();
Ratas objr1=new Ratas(1,"hjjh");
colratas.add(objr1);
Ratas objr2=new Ratas(2,"vcvc");
colratas.add(objr2);
Ratas objr3=new Ratas(3,"bvbv");
colratas.add(objr3);
Ratas objr4=new Ratas(4,"vcvc");
colratas.add(objr4);
Ratas objr5=new Ratas(5,"jhhj");
colratas.add(objr5);
Ratas objr6=new Ratas(6,"fdfd");
colratas.add(objr6);
Ratas objr7=new Ratas(7,"bhbh");
colratas.add(objr7);
Ratas objr8=new Ratas(8,"rddr");
colratas.add(objr8);
Ratas objr9=new Ratas(9,"aqqa");
colratas.add(objr9);
Ratas objr10=new Ratas(10,"kjjk");
colratas.add(objr10);
Ratas objr11=new Ratas(11,"fdfd");
colratas.add(objr11);
Ratas objr12=new Ratas(12,"gfgf");
colratas.add(objr12);
Ratas objr13=new Ratas(13,"vcvc");
colratas.add(objr13);
Ratas objr14=new Ratas(14,"lkkl");
colratas.add(objr14);
Ratas objr15=new Ratas(15,"jhjh");
colratas.add(objr15);
Ratas objr16=new Ratas(16,"vcvc");
colratas.add(objr16);
Ratas objr17=new Ratas(17,"gfgf");
colratas.add(objr17);
Ratas objr18=new Ratas(18,"hghghg");
colratas.add(objr18);
Ratas objr19=new Ratas(19,"gffg");
colratas.add(objr19);
Ratas objr20=new Ratas(20,"rrffr");
colratas.add(objr20);
}
private Ratas[] devolverArray()
{
Ratas[]aux=new Ratas[colratas.size()];
int cont=0;
for(Ratas objr : colratas)
{
aux[cont]=objr;
cont++;
}
return aux;
}
public TreePages<Ratas>devolverPaginas()
{
TreePages<Ratas>paginas=new TreePages(devolverArray(), 5);
return paginas;
}
}

package paginacionnivel2;
public class Ratas
{
private int numero;
private String nombre;
public int getNumero()
{
return numero;
}
public String getNombre()
{
return nombre;
}
public Ratas(int numero, String nombre)
{
this.numero = numero;
this.nombre = nombre;
}
@Override
public String toString()
{
return "RATA:"+ numero + "NOMBRE" + nombre;
}
}

package paginacionnivel2;
public class Cuerpo
{
public static void main(String[] args)
{
Ratas[]aux=ContrRatas.getInstance().devolverPaginas().fir st();
for(Ratas objr : aux)
{
if(objr!=null)
{
System.out.println(objr);
}
}
}
}

necesito ayuda, si me pueden ayudar se los agradezco.

[LuisChavezB]

Es algo difícil de entender tu código, deberías de ponerlo con las etiquetas code.
Si te sirve de algo te dejo una implementacion genérica que yo cree.

Código Java:

public interface Paginable<T> {
    
    public Paginator<T> paginate(int perPage);
}
 

Código Java:

import java.util.List;
import java.util.Iterator;
 
public class Paginator<E> {
 
    private final int perPage;
    private final List<E> collection;
    private int currentPage = -1;
 
    public Paginator(int perPage, List<E> collection) {
        this.perPage = 1 > perPage ? 1 : perPage;
        this.collection = collection;
    }
 
    public int pages() {
        if (null == this.collection || 0 == this.collection.size()) {
            return 0;
        }
 
        return (int) Math.ceil((double) this.collection.size() / this.perPage);
    }
 
    public int currentPage() {
        return this.currentPage + 1;
    }
 
    public boolean hasNext() {
        return currentPage + 1 < this.pages();
    }
 
    public boolean hasPrevious() {
        return currentPage - 1 > 1;
    }
 
    public Iterator<E> items() {
        if (-1 == this.currentPage) {
            throw new IllegalStateException("the pagination is not been initialized");
        }
 
        return new Iterator<E>() {
 
            private final int firstIndex = perPage * currentPage;
            private final int lastIndex = firstIndex + perPage;
            private int index = firstIndex;
 
            @Override
            public boolean hasNext() {
                int newIndex = index + 1;
 
                return newIndex <= lastIndex && newIndex <= collection.size();
            }
 
            @Override
            public E next() {
                return collection.get(index++);
            }
        };
    }
 
    public Iterator<E> next() {
        if (this.hasNext()) {
            ++currentPage;
        }
 
        return this.items();
    }
 
    public Iterator<E> previous() {
        if (this.hasPrevious()) {
            --currentPage;
        }
 
        return this.items();
    }
}
 

Código Java:

import java.util.ArrayList;
 
public class PaginableArrayList<E> extends ArrayList<E> implements Paginable<E> {
 
    @Override
    public Paginator<E> paginate(int perPage) {
        return new Paginator<>(perPage, this);
    }
}
 

Código Java:

PaginableArrayList<Integer> instance = new PaginableArrayList<>();
 
        instance.addAll(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9));
        Paginator<Integer> paginator = instance.paginate(4);
 
        while (paginator.hasNext()) {
            Iterator<Integer> items = paginator.next();
 
            System.out.println("Page: " + paginator.currentPage());
 
            while (items.hasNext()) {
                System.out.println(items.next());
            }
            System.out.println();
        }
 

[detective_jd]

hola LuisChavezB, gracias x responder te tengo buenas noticias: los métodos first, previous, next y last andan bien:

<code>
package paginacionnivel2;
import java.util.*;
public class TreePages<T>
{
private final TreeMap<Integer,T[]>colPaginas=new TreeMap();
private final int cantpaginas;
private final T[]arreglo;
private int nropagina;
private T[]pagina;
public TreePages(T[] xarreglo, int xcantpaginas) {
this.arreglo = xarreglo;
this.cantpaginas = xcantpaginas;
this.nropagina=1;
this.iniciarPaginas();
}
public T[] next(){
if(colPaginas.lastKey()==nropagina)
pagina=last();
else
{
nropagina++;
pagina=colPaginas.get(nropagina);
}
return pagina;
}
public T[] previous() {
if(colPaginas.firstKey()==nropagina)
pagina=first();
else
{
nropagina--;
pagina=colPaginas.get(nropagina);
}
return pagina;
}
public T[] first(){
if(nropagina!=colPaginas.firstKey())
{
nropagina=colPaginas.firstKey();
pagina=colPaginas.get(colPaginas.firstKey());
}
else
{
nropagina=colPaginas.firstKey();
pagina=colPaginas.get(colPaginas.firstKey());
}
return pagina;
}
public T[] last(){
if(nropagina!=colPaginas.lastKey())
{
nropagina=colPaginas.lastKey();
pagina=colPaginas.get(colPaginas.lastKey());
}
else
{
nropagina=colPaginas.lastKey();
colPaginas.get(nropagina);
}
return pagina;
}
private void iniciarPaginas()
{
int cont=1;
int totpaginas=arreglo.length/cantpaginas;
int lower = 0;
int upper = 0;
for(int i=0; i<totpaginas; i++){
upper+=totpaginas;
colPaginas.put(cont,Arrays.copyOfRange(arreglo, lower, upper));
lower = upper;
cont++;
}
if(upper < arreglo.length-1){
lower = upper;
upper = arreglo.length;
colPaginas.put(cont,Arrays.copyOfRange(arreglo, lower, upper));
cont++;
}
}
}
</code>

pero me queda un error en el método iniciarpaginas y es q en la cantidad de registros x pagina pongo 5 y me hace 5 páginas de 4 filas:

<code>
package paginacionnivel2;
import java.util.LinkedList;
public class ContrRatas
{
private static ContrRatas objgestor=null;
private LinkedList<Ratas>colratas=null;
TreePages<Ratas>paginas=null;
public static ContrRatas getInstance()
{
if(objgestor==null)
{
objgestor=new ContrRatas();
}
return objgestor;
}
private ContrRatas()
{
colratas=new LinkedList();
Ratas objr1=new Ratas(1,"hjjh");
colratas.add(objr1);
Ratas objr2=new Ratas(2,"vcvc");
colratas.add(objr2);
Ratas objr3=new Ratas(3,"bvbv");
colratas.add(objr3);
Ratas objr4=new Ratas(4,"vcvc");
colratas.add(objr4);
Ratas objr5=new Ratas(5,"jhhj");
colratas.add(objr5);
Ratas objr6=new Ratas(6,"fdfd");
colratas.add(objr6);
Ratas objr7=new Ratas(7,"bhbh");
colratas.add(objr7);
Ratas objr8=new Ratas(8,"rddr");
colratas.add(objr8);
Ratas objr9=new Ratas(9,"aqqa");
colratas.add(objr9);
Ratas objr10=new Ratas(10,"kjjk");
colratas.add(objr10);
Ratas objr11=new Ratas(11,"fdfd");
colratas.add(objr11);
Ratas objr12=new Ratas(12,"gfgf");
colratas.add(objr12);
Ratas objr13=new Ratas(13,"vcvc");
colratas.add(objr13);
Ratas objr14=new Ratas(14,"lkkl");
colratas.add(objr14);
Ratas objr15=new Ratas(15,"jhjh");
colratas.add(objr15);
Ratas objr16=new Ratas(16,"vcvc");
colratas.add(objr16);
Ratas objr17=new Ratas(17,"gfgf");
colratas.add(objr17);
Ratas objr18=new Ratas(18,"hghghg");
colratas.add(objr18);
Ratas objr19=new Ratas(19,"gffg");
colratas.add(objr19);
Ratas objr20=new Ratas(20,"rrffr");
colratas.add(objr20);
Ratas[]aux=colratas.toArray(new Ratas[colratas.size()]);
paginas=new TreePages(aux, 5);
}
public Ratas[] devolverArray()
{
return colratas.toArray(new Ratas[colratas.size()]);
}
public TreePages<Ratas>devolverPaginas()
{
return paginas;
}
/*
public LinkedList<Ratas>devolverDatosXNombre(String criterio)
{
LinkedList<Ratas>aux =new LinkedList();
for(Ratas objr : colratas)
{
if(objr.getNombre().startsWith(criterio.toUpperCas e())){
aux.add(objr);
}
if(objr.getNombre().startsWith(criterio.toLowerCas e())){
aux.add(objr);
}
}
return aux;
}*/

}
</code>

<code>
package paginacionnivel2;
public class Ratas
{
private int numero;
private String nombre;
public int getNumero()
{
return numero;
}
public String getNombre()
{
return nombre;
}
public Ratas(int numero, String nombre)
{
this.numero = numero;
this.nombre = nombre;
}
@Override
public String toString()
{
return "RATA:"+ numero + " NOMBRE: " + nombre;
}
}
</code>

acá esta el cuerpo del programa:

<code>
package paginacionnivel2;
import java.util.Scanner;
public class Cuerpo
{
private static void MenuPrincipal()
{
Ratas[]aux=null;
Scanner sc=new Scanner(System.in);
System.out.println("");
System.out.println("Menú Principal de la TreePages:");
System.out.println("");
System.out.println("Seleccione su Opción: ");
System.out.println("");
System.out.println("Primero: 1");
System.out.println("Anterior: 2");
System.out.println("Siguiente: 3");
System.out.println("Último: 4");
System.out.println("Salir: 5");
int opcion=sc.nextInt();
if(opcion==1)
{
aux=ContrRatas.getInstance().devolverPaginas().fir st();
listarPagina(aux);
}
else if(opcion==2)
{
aux=ContrRatas.getInstance().devolverPaginas().pre vious();
listarPagina(aux);
}
else if(opcion==3)
{
aux=ContrRatas.getInstance().devolverPaginas().nex t();
listarPagina(aux);
}
else if(opcion==4)
{
aux=ContrRatas.getInstance().devolverPaginas().las t();
listarPagina(aux);
}
else if(opcion==5)
{
System.exit(0);
}
else
{
System.out.println("");
System.out.println("Error. Ingrese una de las opciones que aparece en el sistema");
}
MenuPrincipal();
}
private static void listarPagina(Ratas[]aux)
{
for(Ratas objr : aux)
{
if(objr!=null)
{
System.out.println(objr);
}
}
}
public static void main(String[] args)
{
MenuPrincipal();
}
}
</code>

sólo queda solucionar que cuando pongo en el constructor de la clase ContrRatas y pongo 5 cómo parámetro a la variable paginas, tendría q hacer 4 páginas de 5 filas y no 5 páginas de 4 filas.
si me ayudan se los agradezco.

[detective_jd]

el error era este:

upper+=totpaginas;

lo solucioné:

upper+=cantpaginas;

ahora anda todo bien

la pregunta ahora sería: ¿le agrego los métodos esta vacio, tamaño y limpiar para que quede cómo una estructura de datos?

¿siendo así tendría q hacerlos cómo cualquier estructura de datos o cambia xq ahora es por página clave(nro de página) y valor(el array de la página)?

[detective_jd]

hola, aqui estoy nuevamente solucioné algunos problemas y agregue funcionalidades nuevas, pero tengo ahora el sgte problema q no puedo resolver:

Rata --- Nombre
1 --- Pepe
2 --- Luis
3 --- Juan
4 --- Maria
5 --- Pedro
Página 2
6 --- Peres
7 --- Rodrigo
8 --- Mariana
Elimino Luis y debería quedarme así:
1 --- Pepe
3 --- Juan
4 --- Maria
5 --- Pedro
6 --- Peres
Página 2
7--- Rodrigo
8--- Mariana
Y no se me ocurre nada para que me quede tal cual..

aqui esta el código:

http://pastebin.com/Udh7Ct8d

por favor necesito con esto!, si me ayuden se los agradezco.

[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;
    }
}
 

[detective_jd]

PagesMap (se encuentra en su versión 1.0)

Código Java:

import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.TreeMap;
public class PagesMap<K,V> 
{
    public enum Navegate {
        goToFirst,
        goToPrevious,
        goToNext,
        goToLast,
        goToPresent
    }
    private final ArrayList<LinkedHashMap<K,V>>pages = new ArrayList();
    private final int limit;
    private int filas;
    private int latest;
    private int size;
    private int page;
    public PagesMap() {
        this.limit = 10;
        this.clear();
    }
    public PagesMap(int xlimit) {
        this.limit = xlimit;
        this.clear();
    }    
    private LinkedHashMap<K,V> getNext() {
        return (page == latest) ? getLast() : pages.get(++page);
    }
    private LinkedHashMap<K,V> getPrevious() {
        return (page == 0) ? getFirst() : pages.get(--page);
    }
    private LinkedHashMap<K,V> getFirst() {
        return (page != 0) ? pages.get((page = 0)) : pages.get((page = 0));
    }
    private LinkedHashMap<K,V> getLast() {
        return (page != latest) ? pages.get((page = latest)) : pages.get((page = latest));
    }
    private LinkedHashMap<K,V> getPresent() {
        return pages.get(page);
    }
    public LinkedHashMap<K,V> getReload(Navegate opcion) {
        switch (opcion) {
            case goToFirst:
                getFirst();
                break;
            case goToPrevious:
                getPrevious();
                break;
            case goToNext:
                getNext();
                break;
            case goToLast:
                getLast();
                break;
        }
        return getPresent();
    }
    public final void clear() {
        pages.clear();
        this.page = 0;
        this.filas = 0;
        this.latest = 0;
        LinkedHashMap<K,V> t = new LinkedHashMap();
        pages.add(t);
        this.size = 1;
    }
    public V put(K key,V value) {
        if (key == null) {
            throw new NullPointerException("elemento nulo");
        } 
        else if (limit == filas) {
                filas = 0;
                LinkedHashMap<K,V> t = new LinkedHashMap();
                pages.add(t);
                latest++;                
                pages.get(latest).put(key, value);
                size++;
                filas++;
            }
        else{
            pages.get(latest).put(key, value);
            filas++;
        }       
        return value;
    }    
    public V get(K key){
        for(LinkedHashMap<K,V> p : pages){
            if(p.get(key) != null){
                return p.get(key); 
            }
        }
        return null;
    }
    public boolean containsKey(K key){
        for(LinkedHashMap<K,V> p : pages){
            if(p.containsKey(key)){
                return p.containsKey(key);
            }            
        }
        return false;
    }
    public boolean containsValue(V value){
        for(LinkedHashMap<K,V> p : pages){
            if(p.containsValue(value)){
                return p.containsValue(value);  
            }          
        }
        return false;
    }
    public V remove(K key) {
        LinkedHashMap<K,V> aux = this.toMap();
        V res = aux.get(key);
        aux.remove(key);
        this.clear();
        aux.entrySet().stream().forEach((e) -> {
            this.put(e.getKey(),e.getValue());
        });
        return res;
    }
    public LinkedHashMap<K,V> toMap() {
        LinkedHashMap<K,V> aux = new LinkedHashMap();
        pages.stream().forEach((list) -> {
            list.entrySet().stream().forEach((row) -> {
                aux.put(row.getKey(),row.getValue());
            });
        });
        return aux;
    }
    public void sort(){
        this.sort(null);
    }
    public void sort(Comparator comp){
        TreeMap<K, V> map = new TreeMap(comp);
        this.toMap().entrySet().stream().forEach((e) -> {
            map.put(e.getKey(), e.getValue());
        });
        this.clear();
        map.entrySet().stream().forEach((e) -> {
            this.put(e.getKey(), e.getValue());
        });        
    }
    public PagesMap<K,V>copyTo(){
        PagesMap<K,V> aux= new PagesMap(limit);
        this.toMap().entrySet().stream().forEach((e) -> {
                aux.put(e.getKey(), e.getValue());            
        });
        return aux;
    }
    public boolean isEmpty(){
        return size == 0;
    }
    public int size() {
        return size;
    }        
}
 

PagesSet (se encuentra en su versión 1.0)

Código Java:

import app.contr.util.PagesMap.Navegate;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class PagesSet<E> 
{
    private int limit_copy; 
    private final Object PRESENT = new Object();
    private PagesMap<E,Object> map=new PagesMap();
    public PagesSet() {
        map=new PagesMap();
    }
    public PagesSet(int xlimit) {
        limit_copy = xlimit;
        map=new PagesMap(limit_copy);
        
    }  
    public Set<E> getReload(Navegate opcion) {
        return map.getReload(opcion).keySet();
    }
    public int size() {
        return map.size();
    }
    public boolean isEmpty() {
        return map.isEmpty();
    }
    public boolean contains(E obj) {
        return map.containsKey(obj);
    }
    public boolean add(E obj) {
        return map.put(obj, PRESENT) == null;
    }
    public boolean remove(E obj) {
        return map.remove(obj)==PRESENT;
    }
    public Set<E>toSet(){
        return map.toMap().keySet();
    }
    public void sort(){
        this.sort(null);        
    }
    public void sort(Comparator comp){
        TreeSet<E> aux = new TreeSet<>(comp);
        this.toSet().stream().forEach((e) -> {
            aux.add(e);
        }); 
        this.clear();
        aux.stream().forEach((e) -> {
            this.add(e);
        });
    }
    public PagesSet<E>copyTo(){
        PagesSet<E> aux= new PagesSet(limit_copy);
        this.map.toMap().keySet().stream().forEach((e) -> {
            aux.add(e);
        });
        return aux;
    }
    public void clear() {
        map.clear();
    }
}
 

Saludos a todos y gracias!