Estuctura para paginar

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