Subdividing a Collection into smaller collections

[Promod kumar]

Here is the requirement I have to split a collection into n collections each of a given size. Here is the code, I came up with. I am guessing there is a better way to do this or is there a Collection Utility that does it for me. I looked but could not find it (did a google search and Java ranch search).
Any pointers would be great and thanks for your time.

  
public class CollectionSplitter {
 
static void subDivide(List list, int subCollectionSize, List resultList) {
for (int i = 0; i < list.size() / subCollectionSize + 1; i++) {
int maxLength;
if (i * subCollectionSize + subCollectionSize > list.size())
maxLength = list.size();
else
maxLength = i * subCollectionSize + subCollectionSize;
List sublist = new ArrayList();
for (int j = i * subCollectionSize; j < maxLength; j++) {
 
sublist.add(list.get(j));
}
resultList.add(sublist);
}
}
 
public static void main(String[] args) {
List resultList = new ArrayList();
List list = new ArrayList();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
list.add("six");
list.add("seven");
list.add("eight");
list.add("nine");
list.add("ten");
list.add("eleven");
subDivide(list, 5, resultList);

}
}

[Promod kumar]

I actually found a sublist after I posted the message. Is that the better way of doing this.

[Ganesh Gowtham]

public class CollectionSplitter {

static List split(List srcList, int index) {
List d = new ArrayList();
for (int i = 0; i < srcList.size(); i = i + 4) {
if ((i + 4) <= srcList.size())
d.add(srcList.subList(i, i + 4));
else
d.add(srcList.subList(i, srcList.size() - 1));
}
return d;
}

public static void main(String[] args) {
List resultList = new ArrayList();
List list = new ArrayList();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
list.add("six");
list.add("seven");
list.add("eight");
list.add("nine");
list.add("ten");
list.add("eleven");
resultList = split(list, 5);
}
}

if there is still simple let me know

[Promod kumar]

Gowtham,
Yours looks simple. Anyway here is my new version

public class CollectionSplitter {
 
/**
 * @param args
 */
static void subDivide(List list, int subCollectionSize, List resultList) {
if (list.size() <= subCollectionSize) {
resultList.add(list);
return;
}
for (int i = 0; i < getNumberOfIterations(list, subCollectionSize); i++) {
int maxLength = ((i + 1) * subCollectionSize > list.size()) ? list
.size() : (i + 1) * subCollectionSize;
List sublist = new ArrayList();
sublist.add(list.subList(i * subCollectionSize, maxLength));
resultList.add(sublist);
}
}
 
private static int getNumberOfIterations(List list, int subCollectionSize) {
return list.size() % subCollectionSize == 0 ? list.size()
/ subCollectionSize : (list.size() / subCollectionSize) + 1;
}
 
public static void main(String[] args) {
List resultList = new ArrayList();
List list = new ArrayList();
 
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
 
list.add("six");
list.add("seven");
list.add("eight");
list.add("nine");
list.add("ten");
list.add("eleven");
 
subDivide(list, 3, resultList);
 
}
}

[Vihung Marathe]

How about something like

    public static List[] split(final List pList, final int pSize)
    {
        if(pList == null || pList.size() == 0 || pSize == 0) return new List[] {};
        if(pSize < 0) return new List[] { pList };
 
        // Calculate the number of batches
        int numBatches = (pList.size() / pSize) + 1;
 
        // Create a new array of Lists to hold the return value
        List[] batches = new List[numBatches];
 
        for(int index = 0; index < numBatches; index++)
        {
            int count = index + 1;
            int fromIndex = Math.max(((count - 1) * pSize), 0);
            int toIndex = Math.min((count * pSize), pList.size());
            batches[index] = pList.subList(fromIndex, toIndex);
        }
 
        return batches;
    }

[Niran Abeygunawardena]

I realise this an old post but it comes up high in web searches for this topic.

So, here is an alternative solution basically adapted from the google collections apis. It uses generics to return a list of lists which are of the specified size. Just call the static method partition() with your parameters.

 
  /**
   * Returns consecutive {@linkplain List#subList(int, int) sublists} of a list,
   * each of the same size (the final list may be smaller). For example,
   * partitioning a list containing {@code [a, b, c, d, e]} with a partition
   * size of 3 yields {@code [[a, b, c], [d, e]]} -- an outer list containing
   * two inner lists of three and two elements, all in the original order.
   * <p/>
   * Adapted from http://code.google.com/p/google-collections/
   *
   * @param list the list to return consecutive sublists of
   * @param size the desired size of each sublist (the last may be
   *             smaller)
   * @return a list of consecutive sublists
   * @throws IllegalArgumentException if {@code size} is non-positive
   */
  public static <T> List<List<T>> partition(List<T> list, int size) {
 
   if (list == null)
      throw new NullPointerException(
          "'list' must not be null");
    if (!(size > 0))
      throw new IllegalArgumentException(
          "'size' must be greater than 0");

    return new Partition<T>(list, size);
  }

  private static class Partition<T> extends AbstractList<List<T>> {

    final List<T> list;
    final int size;

    Partition(List<T> list, int size) {
      this.list = list;
      this.size = size;
    }

    @Override
    public List<T> get(int index) {
      int listSize = size();
      if (listSize < 0)
        throw new IllegalArgumentException("negative size: " + listSize);
      if (index < 0)
        throw new IndexOutOfBoundsException(
            "index " + index + " must not be negative");
      if (index >= listSize)
        throw new IndexOutOfBoundsException(
            "index " + index + " must be less than size " + listSize);
      int start = index * size;
      int end = Math.min(start + size, list.size());
      return list.subList(start, end);
    }

    @Override
    public int size() {
      return (list.size() + size - 1) / size;
    }

    @Override
    public boolean isEmpty() {
      return list.isEmpty();
    }
  }

[Lars Vogel]

Hello,

thanks this discussion was helpful. Based on your discussion I have created a little summary and a JUnit test which can be found here:
http://www.vogella.de/articles/JavaAlgorithmsPartitionCollection/article.html

I did include this discussion as the source of information in the article.

Thanks again, Lars

[Mehmet Ali Kipcak]

Niran Abeygunawardena wrote:I realise this an old post but it comes up high in web searches for this topic.

So, There is another alternative solution by using enumerations and not instantiating multiple list objects at once .

 
		public static <T1> Enumeration<List<T1>> createPartitionedEnum(final List<T1> originalList, final int blockSize){
			
			class PartitionedEnum 
				implements Enumeration<List<T1>> {
				
				int lastIndex = 0;

				public boolean hasMoreElements() {
					return this.lastIndex < originalList.size();
				}

				public List<T1> nextElement() {
					int beginIndex 	= this.lastIndex;
					int endIndex 	= 0;
					if (this.lastIndex + blockSize > originalList.size()){
						endIndex = originalList.size(); 			
					} else {
						endIndex = this.lastIndex + blockSize;
					}
					this.lastIndex = endIndex;
					return originalList.subList(beginIndex, endIndex);
				}
			} 
 
			return new PartitionedEnum();
		}

		public static void main(String[] args) {
 
			List<String> list = new ArrayList<String>();
			list.add("one");
			list.add("two");
			list.add("three");
			list.add("four");
			list.add("five");
			list.add("six");
			list.add("seven");
			list.add("eight");
			list.add("nine");
			list.add("ten");
			list.add("eleven");
			
			Enumeration<List<String>> enm = createPartitionedEnum(list, 4);
			int blockNumber=1;
			while(enm.hasMoreElements()){
				for(String number: enm.nextElement()){
					System.out.println("["+blockNumber+"]"+number);
				}
				blockNumber++;
			}
		}