Java分頁列表

Question

我有3 List不同類型的Objects。 例如：

ListA包含64元素。

ListB包含33元素。

ListC包含515元素。

因此，總共有612元素。

我想讓組（Pagination）100元素，例如，它應該是這樣的：

頁1：ListA：64元/ ListB：33元/ ListC：3元素

頁面2：ListA：0 elements/ListB：0元件/ ListC：100元件

頁3：ListA：0元件/ ListB：0元件/ ListC：100元件

頁4：ListA：0元件/ ListB：0元件/ ListC：100元件

頁5：ListA：0元件/ ListB：0元件/ ListC：100元件

頁6：ListA：0元件/ ListB： 0 elements/ListC：100元素

頁7：ListA：0元/ ListB：0元/ ListC：12元素

我的想法是創建一個Map<Integer, List<List>，其中key將是Page和value一個List其中包含3個Lists（每個ListA，B或C）。

這裏是我的代碼：

  int totalPages = 0; 
      int totalElements = listA.size() + listB.size() + listC.size(); 
      if(totalElements % PAGE_SIZE == 0) { 
       totalPages = totalElements/PAGE_SIZE; 
      }else { 
       totalPages = (totalElements/PAGE_SIZE) + 1; 
      } 


      Map<Integer, List<List<ParentObject>>> paginatedMap = new HashMap<Integer, List<List<ParentObject>>>(); 
      for(int i=0; i<totalPages; i++) { 
       List<List<ParentObject>> list = new LinkedList<List<ParentObject>>(); 
       List<ObjectA> subListA = new LinkedList<ObjectA>(); 
       List<ObjectB> subListB = new LinkedList<ObjectB>(); 
       List<ObjectC> subListC = new LinkedList<ObjectC>(); 
       int total = 0; 

       if(total <= PAGE_SIZE) { 
        subListA.addAll(listA.subList(0, (PAGE_SIZE-total)-1)); 
        listA.removeAll(listA.subList(0, (PAGE_SIZE-total)-1)); 
        total = total + subListA.size(); 
       } 

       if(total <= PAGE_SIZE) { 
        subListB.addAll(listB.subList(0, (PAGE_SIZE-total)-1)); 
        listB.removeAll(listB.subList(0, (PAGE_SIZE-total)-1)); 
        total = total + subListB.size(); 
       } 

       if(total <= PAGE_SIZE) { 
        subListC.addAll(listC.subList(0, (PAGE_SIZE-total)-1)); 
        listC.removeAll(listC.subList(0, (PAGE_SIZE-total)-1)); 
        total = total + subListC.size(); 
       } 

       list.add(subListA); 
       list.add(subListB); 
       list.add(subListC); 
       paginatedMap.put(i, list); 
      } 

其中PAGE_SIZE是100

這是不工作，因爲我當然需要檢查多少元素每個list包含調用subListmethod之前。

我想我走錯了路，但我沒有看到另一種方式來做到這一點。

任何想法？

謝謝！

最後我得到它的工作。 這裏是代碼：

private Map<Integer, List<List<MyObject>>> paginateDataRequest(List<List<MyObject>> requestLists, double pageSize) { 
    Map<Integer, List<List<MyObject>>> result = new LinkedHashMap<Integer, List<List<MyObject>>>(); 
    int totalElements = 0; 

    //We calculate the total of the elements contained in the requestLists. 
    for(List<MyObject> subList : requestLists) { 
     if(subList != null) { 
      totalElements += subList.size(); 
     } 
    } 

    //We round it up. The result Map will contain x pages with {pageSize} elements each one. For example, if the total amount of request is 101, 
    //our Map will have 2 pages (100 elements + 1 element) 
    int totalRequests = (int)Math.ceil(totalElements/pageSize); 

    //We iterate over each page 
    for(int i=0; i<totalRequests; i++) { 
     List<List<MyObject>> entry = new LinkedList<List<MyObject>>(); 

     int freeElements = (int)pageSize; 

     for(List<MyObject> list : requestLists) { 
      List<MyObject> subList = new LinkedList<MyObject>(); 
      if(freeElements > 0) { 
       if(list.size() > freeElements) { 
        subList.addAll(list.subList(0, freeElements)); 
       }else { 
        subList.addAll(list); 
       } 
       //We update the left free elements 
       freeElements -= subList.size(); 
      } 
      entry.add(subList); 
      list.removeAll(subList); 

     } 
     //We add a new page to the result Map 
     result.put(i, entry); 
    } 

    return result; 
} 

謝謝大家的幫助！

Answer 1

您可以將所有不同的對象放在一個List中，並使用instanceof來檢測類的類型。

Answer 2

這不起作用，因爲我當然需要在調用subList方法之前檢查每個list包含多少個元素。

這似乎只是問題，如果你不願意檢查列表的大小。讓至多大到整個列表子列表通過檢查大小第一...

代替

listB.removeAll(listB.subList(0, (PAGE_SIZE-total)-1)); 

你也應該使用

listB.subList(0, (PAGE_SIZE-total)-1).clear(); 

防止相等的元素被移除偶然。

下面的方法提出了一個更加可重用的方式做任務，因爲它不依賴於列表的具體數量，也不會修改源列表：從3獨立List

轉換輸入數據結構s到包含這些列表的列表。這使您可以跟蹤列表的索引以獲取元素以及此列表中元素的第一個索引尚未使用。這樣，您可以簡單地瀏覽列表並添加項目，直到頁面已滿。

下面的代碼返回一個List代替Map，因爲鍵是數字0，...，N，但它可以很容易地修改，以返回地圖：

public static <T> List<List<List<T>>> paginate(List<? extends List<? extends T>> objects, final int pageSize) { 
    List<List<List<T>>> result = new ArrayList<>(); 

    int index = 0; 
    int size = objects.size(); 

    // skip empty lists 
    while (index < size && objects.get(index).isEmpty()) { 
     index++; 
    } 

    for (int pageIndex = 0; index < size;) { 
     int remaining = pageSize; 
     List<List<T>> page = new ArrayList<>(size); 
     result.add(page); 
     for (int i = 0; i < index; i++) { 
      page.add(Collections.emptyList()); 
     } 
     while (remaining > 0 && index < size) { 
      List<? extends T> source = objects.get(index); 
      int lastIndex = Math.min(source.size(), pageIndex + remaining); 
      List<T> list = new ArrayList<>(source.subList(pageIndex, lastIndex)); 
      page.add(list); 
      remaining -= lastIndex - pageIndex; 
      if (lastIndex == source.size()) { 
       index++; 
       pageIndex = 0; 
       // skip empty lists 
       while (index < size && objects.get(index).isEmpty()) { 
        page.add(Collections.emptyList()); 
        index++; 
       } 
      } else { 
       pageIndex = lastIndex; 
      } 
     } 
     for (int i = page.size(); i < size; i++) { 
      page.add(Collections.emptyList()); 
     } 
    } 

    return result; 
} 

Answer 3

天真的建設每次都有一個全局列表（它的優點在於它始終使用底層列表的最後一個版本）。

public class ListPager { 

    public List<List<Object>> lists = new ArrayList<List<Object>>(); 

    public int _pageSize = 100; 

    public void addList(List<Object> list) { 
     lists.add(list); 
    } 

    public List<Object> getPage(int p) { 
     List<Object> global = new ArrayList<Object>(); 
     for (List<Object> l : lists) { 
      global.addAll(l); 
     } 
     if (p*_pageSize > global.size()) return global; 
     int maxBound = (p + 1)*_pageSize; 
     if (maxBound > global.size()) { 
      maxBound = p*_pageSize + (global.size()%(p*_pageSize)); 
     } 
     return global.subList(p*_pageSize, maxBound); 
    } 
} 

相關的測試類：

public class ListPagerTest { 

    public static class ObjectA { 
     public String toString() { return "A"; } 
    } 
    public static class ObjectB { 
     public String toString() { return "B"; } 
    } 
    public static class ObjectC { 
     public String toString() { return "C"; } 
    } 

    @Test 
    public void test() { 
     List<Object> listA = new ArrayList<Object>(); 
     for (int i = 0 ; i < 64 ; i++) { listA.add(new ObjectA()); } 
     List<Object> listB = new ArrayList<Object>(); 
     for (int i = 0 ; i < 33 ; i++) { listB.add(new ObjectB()); } 
     List<Object> listC = new ArrayList<Object>(); 
     for (int i = 0 ; i < 515 ; i++) { listC.add(new ObjectC()); } 

     ListPager lp = new ListPager(); 
     lp.addList(listA); 
     lp.addList(listB); 
     lp.addList(listC); 

     for (int i = 0 ; i < 7 ; i++) { 
      System.out.println("Page " + i); 
      print(lp.getPage(i)); 
     } 
    } 

    public static void print(List<Object> l) { 
     StringBuffer out = new StringBuffer(); 
     for (Object o : l) out.append(o + ","); 
     System.out.println(out.toString()); 
    } 

}