Javaページ番号リスト

Question

私は、Objectsの3種類のListを持っています。 例：

ListAには、64要素が含まれています。

ListBは、33要素を含んでいます。

ListCは、515要素を含んでいます。

合計で、私は612要素を持っています。私は100要素のグループ（Pagination）を作りたい

は、例えば、それは次のようになります。

ページ1：ListA：64要素/ ListB：33要素/ ListC：3要素を

ページ2：ListA：0要素/ 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要素/ ListC：100要素

ページ7：ListA：0要素/ ListB：0要素/ ListC：12要素

私の考えはMap<Integer, List<List>keyは次のようになりどこPageとvalue作成されますListは、3つのLists（各1つにつき、ListA,BまたはC）。 PAGE_SIZEはもちろん、私はどのように多くの要素をチェックする必要があるため働いていない100

ある

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

がそれぞれ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

すべての異なるオブジェクトを1つのリストに入れ、instanceofを使用してクラスのタイプを検出できます。

Answer 2

もちろん、メソッドを呼び出す前に、それぞれlistに含まれる要素の数を確認する必要があるため、これは機能しません。

これは、リストのサイズを確認したくない場合にのみ問題になると思われます。あなたが削除されてから同じ要素を防ぐために

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

を使用する必要があります...最初のサイズをチェックして、代わりに

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

のも

をリスト全体として大きなとしてせいぜいサブリスト作ります偶然にも。

以下のアプローチは、リストの特定の数に依存しないと、ソースリストを変更していないため、タスクを実行するために、より再利用可能な方法を提示：

3別々Listからの入力データ構造を変換しますこれらのリストを含むリストに追加します。これにより、リストから要素を取得するためのリストのインデックスと、まだ使用されていないこのリスト内の要素の最初のインデックスを追跡することができます。この方法では、ページがいっぱいになるまでリストを通って項目を追加するだけです。

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

ナイーブ溶液ビル：キーが...、数字0であり、nは、容易に地図を返すように修正することができるので

次のコードは、代わりMapのListを返します毎回グローバルリスト（それはいつも根本的なリストの最後のバージョンを取るという利点があります）。

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

}