有沒有簡單的方法將ONE列表拆分爲X個子列表？

Question

我有一個隨機大小大於20k的列表。我怎樣才能將它們分成子列表，其中每個子列表將具有相同的長度或等於+1（奇數列表？）？

由於它是隨機大小，實現應該沒有任何定義的大小正確嗎？

我目前正在研究這個模板：

public static <T> List<List<T>> split(List<T> list, int size) throws NullPointerException, IllegalArgumentException { 
     if (list == null) { 
      throw new NullPointerException("The list parameter is null."); 
     } 
     if (size <= 0) { 
      throw new IllegalArgumentException("The size parameter must be more than 0."); 
     } 

     int num = list.size()/size; 
     int mod = list.size() % size; 
     List<List<T>> ret = new ArrayList<List<T>>(mod > 0 ? num + 1 : num); 
     for (int i = 0; i < num; i++) { 
      ret.add(list.subList(i * size, (i + 1) * size)); 
     } 
     if (mod > 0) { 
      ret.add(list.subList(num * size, list.size())); 
     } 
     return ret; 
    } 

這一個是創建子列表基於已知子表的大小，然後創建X子列表。

我需要的結果是傳遞一個LIST和一個目標sublistSize。所以我通過一個大小爲26346的記錄和子列表大小爲5的列表。最終我會得到5個子列表。前四個子列表將包含5269條記錄，最後一個（第五個）子列表將包含5270條記錄。

Answer 1

這個怎麼樣？這將完成你所說的（如果項目順序不重要），創建'尺寸'子列表，並將所有項目分配到新列表中。

public static <T> List<List<T>> split(List<T> list, int size) 
     throws NullPointerException, IllegalArgumentException { 
    if (list == null) { 
     throw new NullPointerException("The list parameter is null."); 
    } 

    if (size <= 0) { 
     throw new IllegalArgumentException(
       "The size parameter must be more than 0."); 
    } 

    List<List<T>> result = new ArrayList<List<T>>(size); 

    for (int i = 0; i < size; i++) { 
     result.add(new ArrayList<T>()); 
    } 

    int index = 0; 

    for (T t : list) { 
     result.get(index).add(t); 
     index = (index + 1) % size; 
    } 

    return result; 
} 

Answer 2

如果你想保持在每個子列表的大型列表的順序，請嘗試以下操作：

public static <T> List<List<T>> split(List<T> list, int numberOfLists) { 
    if (list == null) { 
     throw new NullPointerException("The list parameter is null."); 
    } 
    if (numberOfLists <= 0) { 
     throw new IllegalArgumentException(
       "The number of lists parameter must be more than 0."); 
    } 

    int sizeOfSubList = list.size()/numberOfLists + 1; 
    int remainder = list.size() % numberOfLists; 

    List<List<T>> subLists = new ArrayList<List<T>>(numberOfLists); 

    // if there is a remainder, let the first sub-lists have one length... 
    for (int i = 0; i < numberOfLists - remainder; i++) { 
     subLists.add(list.subList(i*sizeOfSubList, (i+1)*sizeOfSubList)); 
    } 

    // ... the remaining sub-lists will have -1 size than the first. 
    sizeOfSubList--; 
    for (int i = numberOfLists - remainder; i < numberOfLists; i++) { 
     subLists.add(list.subList(i*sizeOfSubList, (i+1)*sizeOfSubList)); 
    } 

    return subLists; 
} 

Answer 3

這將根據所需大小的主列表分成子列表的子列表。

public List splitListToSubList(List<Object> parentList, int childListSize) { 
    List<List<Object>> childList = new ArrayList<List<Object>>(); 
    List<Object> tempList = new ArrayList<Object>(); 
    int count = 0; 
    if (parentList != null) { 
     for (Object obj : parentList) { 
      if (count < childListSize) { 
       count = count + 1; 
       tempList.add(obj); 
      } else { 
       childList.add(tempList); 
       tempList = new ArrayList<Object>(); 
       tempList.add(obj); 
       count = 1; 
      } 

     } 
     if (tempList.size() < childListSize) { 
      childList.add(tempList); 
     } 
    } 
    return childList; 
} 

}

Answer 4

這是使用優化的sublist方法Hamsar的aproch的改善。

public static <T> List<List<T>> splitListToSubLists(List<T> parentList, int subListSize) { 
    List<List<T>> subLists = new ArrayList<List<T>>(); 
    if (subListSize > parentList.size()) { 
    subLists.add(parentList); 
    } else { 
    int remainingElements = parentList.size(); 
    int startIndex = 0; 
    int endIndex = subListSize; 
    do { 
     List<T> subList = parentList.subList(startIndex, endIndex); 
     subLists.add(subList); 
     startIndex = endIndex; 
     if (remainingElements - subListSize >= subListSize) { 
      endIndex = startIndex + subListSize; 
     } else { 
      endIndex = startIndex + remainingElements - subList.size(); 
     } 
     remainingElements -= subList.size(); 
    } while (remainingElements > 0); 

    } 
    return subLists; 

}

Answer 5

嘗試一下本作mantaining在子列表主列表的順序。

public <T> List<List<T>> orderedSplit(List<T> list, int lists) throws NullPointerException, IllegalArgumentException { 
    if (list == null) { 
     throw new NullPointerException("La lista es nula."); 
    } 

    if (lists <= 0) { 
     throw new IllegalArgumentException("La lista debe divirse en una cantidad mayor a 0."); 
    } 

    if(list.size() < lists){ 
     throw new IllegalArgumentException("El tamaño de la lista no es suficiente para esa distribución."); 
    } 

    List<List<T>> result = new ArrayList<List<T>>(lists); 

    int listsSize = list.size()/lists; 
    int remainder = list.size() % lists; 

    int index = 0; 
    int remainderAccess = 0; 
    int from = index*listsSize + remainderAccess; 
    int to = (index+1)*listsSize + remainderAccess; 

    while(lists > index){ 

     if(remainder != 0){ 
      result.add(list.subList(from, to+1)); 
      remainder--; 
      remainderAccess++; 
     }else { 
      result.add(list.subList(from, to)); 
     } 

     index++; 
     from = index*listsSize + remainderAccess; 
     to = (index+1)*listsSize + remainderAccess; 
    } 

    return result; 
}