PaginationHelper

PaginationHelper<Character> helper = new PaginationHelper(Arrays.asList('a', 'b', 'c', 'd', 'e', 'f'), 4);
helper.pageCount(); //should == 2
helper.itemCount(); //should == 6
helper.pageItemCount(0); //should == 4
helper.pageItemCount(1); // last page - should == 2
helper.pageItemCount(2); // should == -1 since the page is invalid

// pageIndex takes an item index and returns the page that it belongs on
helper.pageIndex(5); //should == 1 (zero based index)
helper.pageIndex(2); //should == 0
helper.pageIndex(20); //should == -1
helper.pageIndex(-10); //should == -1

PaginationHelper<Character> helper = new PaginationHelper(Arrays.asList('a', 'b', 'c', 'd', 'e', 'f'), 4);
helper.pageCount(); //should == 2
helper.itemCount(); //should == 6
helper.pageItemCount(0); //should == 4
helper.pageItemCount(1); // last page - should == 2
helper.pageItemCount(2); // should == -1 since the page is invalid

// pageIndex takes an item index and returns the page that it belongs on
helper.pageIndex(5); //should == 1 (zero based index)
helper.pageIndex(2); //should == 0
helper.pageIndex(20); //should == -1
helper.pageIndex(-10); //should == -1

import java.util.List;
public class PaginationHelper<I> {
    private List<I> collection;
    private int itemsPerPage;
    public PaginationHelper(List<I> collection, int itemsPerPage){
        this.collection = collection;
        this.itemsPerPage = itemsPerPage;
    }    
    public int itemCount(){
        return collection.size();
    }    
    public int pageCount(){
       int count = itemCount() % itemsPerPage == 0 ? itemCount() / itemsPerPage : itemCount() / itemsPerPage + 1;
        return count;
    }    
    public int pageItemCount(int pageIndex){
        if(pageIndex >= pageCount()){
            return -1;
        }            
        int count = pageIndex < pageCount() - 1 ? itemsPerPage : itemCount() - itemsPerPage * (pageCount() - 1);
        return count;
    }        
    public int pageIndex(int itemIndex){
        int pageIndex = -1;
        if(itemIndex >= itemCount() || itemIndex < 0){
            return pageIndex;
        }    
        pageIndex = itemIndex / itemsPerPage;
        return pageIndex;
    }    
}

import java.util.List;
import java.lang.Math;

// TODO: complete this object/class

public class PaginationHelper<I> {

  private final int itemsPerPage;
  private final List<I> collection;
  
  /**
   * The constructor takes in an array of items and a integer indicating how many
   * items fit within a single page
   */
  public PaginationHelper(List<I> collection, int itemsPerPage) {
    this.itemsPerPage = itemsPerPage;
    this.collection = collection;
  }
  
  /**
   * returns the number of items within the entire collection
   */
  public int itemCount() {
    return collection.size();
  }
  
  /**
   * returns the number of pages
   */
  public int pageCount() {
    return (int)Math.ceil(itemCount() / (float)itemsPerPage);
  }
  
  /**
   * returns the number of items on the current page. page_index is zero based.
   * this method should return -1 for pageIndex values that are out of range
   */
  public int pageItemCount(int pageIndex) {
    if (pageIndex >= pageCount() || pageIndex < 0) 
      return -1;
    else if (pageIndex < pageCount()-1)
      return itemsPerPage;
    else
      return itemCount() % itemsPerPage;
  }
  
  /**
   * determines what page an item is on. Zero based indexes
   * this method should return -1 for itemIndex values that are out of range
   */
  public int pageIndex(int itemIndex) {
    if (itemIndex >= itemCount() || itemIndex < 0)
      return -1;
    else
      return itemIndex / itemsPerPage;  
  }
}

import java.util.List;

public class PaginationHelper<I> {

  int item_count;
  int items_per_page;
  int page_count;

  /**
   * The constructor takes in an array of items and a integer indicating how many
   * items fit within a single page
   */
  public PaginationHelper(List<I> collection, int itemsPerPage) {
    item_count = collection.size();
    items_per_page = itemsPerPage;
    page_count = (item_count + items_per_page - 1) / items_per_page;    
  }
  
  /**
   * returns the number of items within the entire collection
   */
  public int itemCount() {
    return item_count; 
  }
  
  /**
   * returns the number of pages
   */
  public int pageCount() {
    return page_count; 
  }
  
  /**
   * returns the number of items on the current page. page_index is zero based.
   * this method should return -1 for pageIndex values that are out of range
   */
  public int pageItemCount(int pageIndex) {
    if (pageIndex < 0 || pageIndex >= page_count)
      return -1;
    else if (pageIndex == page_count - 1)
      return item_count % items_per_page;
    else
      return items_per_page;  
  }
  
  /**
   * determines what page an item is on. Zero based indexes
   * this method should return -1 for itemIndex values that are out of range
   */
  public int pageIndex(int itemIndex) {
    if (itemIndex < 0 || itemIndex >= item_count)
      return -1;
    else
      return itemIndex / items_per_page;  
  }
}

import java.util.List;

public class PaginationHelper<I> {
 
   public List<I> items;
   public int perPage;

  public PaginationHelper(List<I> collection, int itemsPerPage) {
    items = collection;
    perPage = itemsPerPage;
  }
  
  public int itemCount() {
     return items.size();
  }

  public int pageCount() {
    return this.itemCount() / perPage + 1;
  }
  
  public int pageItemCount(int pageIndex) {
    return (pageIndex >= this.pageCount())? -1 : ((pageIndex == this.pageCount()-1)? this.itemCount() % perPage : perPage);
  }

  public int pageIndex(int itemIndex) {
    return (itemIndex < 0 || itemIndex > this.itemCount()-1)? -1 : itemIndex / perPage;
  }
}