Main.java Source code

Introduction

Here is the source code for Main.java

Source

//package com.java2s;
/*
 * Copyright (C) 2000 - 2012 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);
    }
}