× Home Tutorials Training Consulting Products Books Company Donate Contact us

NOW Hiring

Quick links


Partition a collection into smaller collections. This article describes how to partition a collections into a given number of smaller collections.

1. Partition a collection

Sometimes you want to split a collection into smaller collections. The following gives an example how to do this.

Please note that this example is an adjusted example of the Google collection and more or less the same as Code Ranch discussion. The Google source code can be found here Original source code.

The test code also demonstrates how to calculate the number of elements which should go into one bucket in case you want to have a fixed number of buckets.

2. Partition collection in Java

2.1. Implementation

Create a Java project "de.vogella.algorithms.partitioncollection".

Create the following program.

package de.vogella.algorithms.partitioncollection;

import java.util.AbstractList;
import java.util.List;

public class MyPartition {

           * 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>The outer list is unmodifiable, but reflects the latest state of the
           * source list. The inner lists are sublist views of the original list,
           * produced on demand using {@link List#subList(int, int)}, and are subject
           * to all the usual caveats about modification as explained in that API.
           * * 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 partitionSize} is nonpositive


          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;

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

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

            public boolean isEmpty() {
              return list.isEmpty();


2.2. Test

You can use the following JUnit test to validate the result.

package de.vogella.algorithms.partitioncollection;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

import static org.junit.Assert.assertTrue;

public class MyPartitionTest {
        public void partitiontest1() {
                List<String> list = new ArrayList<String>();
                List<List<String>> partition = MyPartition.partition(list, 1);
                partition = MyPartition.partition(list, 7);

                // now let assume you want to have x number of buckets
                // How many elements must placed in a list?
                // Take x as 3

                int buckets = 3;
                int divide = list.size() / buckets;
                if (list.size() % buckets !=0){
                        divide ++;
                System.out.println("Max. number of element in each bucket " + divide);
                partition = MyPartition.partition(list, divide );

3. About this website

4. Links and Literature

4.1. Source Code

Not listed yet.

4.3. vogella GmbH training and consulting support


The vogella company provides comprehensive training and education services from experts in the areas of Eclipse RCP, Android, Git, Java, Gradle and Spring. We offer both public and inhouse training. Whichever course you decide to take, you are guaranteed to experience what many before you refer to as “The best IT class I have ever attended”.

The vogella company offers expert consulting services, development support and coaching. Our customers range from Fortune 100 corporations to individual developers.

Copyright © 2012-2016 vogella GmbH. Free use of the software examples is granted under the terms of the EPL License. This tutorial is published under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Germany license.

See Licence.