Java Collection Split split(final Collection collection)

Description

Splits a collection into several collections.

License

Open Source License

Parameter

Parameter	Description
collection	a parameter

Declaration

public static <T> Collection<Collection<T>> split(final Collection<T> collection) 

Method Source Code

//package com.java2s;
/*// w w  w . jav a2  s.c o m
 * Copyright (C) 2000 - 2013 Silverpeas
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * As a special exception to the terms and conditions of version 3.0 of
 * the GPL, you may redistribute this Program in connection with Free/Libre
 * Open Source Software ("FLOSS") applications as described in Silverpeas's
 * FLOSS exception.  You should have recieved a copy of the text describing
 * the FLOSS exception, and it is also available here:
 * "http://www.silverpeas.org/docs/core/legal/floss_exception.html"
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

import java.util.ArrayList;

import java.util.Collection;
import java.util.Collections;

public class Main {
    /**
     * Splits a collection into several collections. (Particularly useful for limitations of database
     * around the "in" clause)
     * @param collection
     * @return
     */
    public static <T> Collection<Collection<T>> split(final Collection<T> collection) {
        return split(collection, 500);
    }

    /**
     * Splits a collection into several collections. (Particularly useful for limitations of database
     * around the "in" clause)
     * @param collection
     * @param collectionSizeMax
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> Collection<Collection<T>> split(final Collection<T> collection, final int collectionSizeMax) {
        Collection<Collection<T>> result = null;

        try {
            if (isNotEmpty(collection)) {
                if (collectionSizeMax > 0 && collection.size() > collectionSizeMax) {

                    // Guessing the result size and initializing the result
                    int size = (collection.size() / collectionSizeMax);
                    if ((collection.size() % collectionSizeMax) != 0) {
                        size++;
                    }
                    result = new ArrayList<Collection<T>>(size);

                    // Browsing the collection
                    Collection<T> curLot = null;
                    for (final T element : collection) {

                        // If necessary, initializing a lot
                        if (curLot == null || curLot.size() >= collectionSizeMax) {
                            curLot = new ArrayList<T>(collectionSizeMax);

                            // Adding the new lot
                            result.add(curLot);
                        }

                        // Adding an element into the current lot
                        curLot.add(element);
                    }
                } else {
                    result = Collections.singletonList(collection);
                }
            }
        } catch (final Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (result == null) {
                result = new ArrayList<Collection<T>>();
            }
        }

        // Retour du resultat
        return result;
    }

    /**
     * Checks if the given collection is instancied and not empty
     * @param <T>
     * @param collection
     * @return
     */
    public static <T> boolean isNotEmpty(final Collection<T> collection) {
        return collection != null && !collection.isEmpty();
    }

    /**
     * Checks if the given collection is not instancied or empty
     * @param <T>
     * @param collection
     * @return
     */
    public static <T> boolean isEmpty(final Collection<T> collection) {
        return !isNotEmpty(collection);
    }
}

Related

1. getSymbolSplitString(Collection collection, String symbol)
2. split(Collection d, int n)
3. split(Collection collections, String separator)
4. split(Collection orig, int batchSize)
5. split(Collection set, int n)
6. splitAndKeepEscapedSpaces(String string, boolean preserveEscapes, Collection into)
7. splitToCollection(Collection collection, String valueString)
8. splitToCollection(String list, String separator, Collection dest)
9. splitToCollection(String str, String sep, Collection c)