集合工具类

package com.xxx.xxx.common.util;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 集合工具类
 */
public class CollectionUtils extends org.springframework.util.CollectionUtils {

    /**
     * 检查Map是否不为空
     *
     * @param map 需要检查的Map
     * @return 是否不为空
     */
    public static boolean isNotEmpty(Map<?, ?> map) {
        return !isEmpty(map);
    }

    /**
     * 检查Collection是否不为空
     *
     * @param collection 需要检查的Map
     * @return 是否不为空
     */
    public static boolean isNotEmpty(Collection<?> collection) {
        return !isEmpty(collection);
    }

    /**
     * 计算笛卡儿积
     *
     * @param crossArgs a {@link List} object.
     * @param <T>       a T object.
     * @return a {@link List} object.
     */
    public static <T> List<List<T>> descartes(List<List<T>> crossArgs) {
        // 计算出笛卡尔积行数
        int rows = crossArgs.size() > 0 ? 1 : 0;
        for (List<T> data : crossArgs) {
            rows *= data.size();
        }
        // 笛卡尔积索引记录
        int[] record = new int[crossArgs.size()];
        List<List<T>> results = new ArrayList<>();
        // 产生笛卡尔积
        for (int i = 0; i < rows; i++) {
            List<T> row = new ArrayList<>();
            // 生成笛卡尔积的每组数据
            for (int index = 0; index < record.length; index++) {
                row.add(crossArgs.get(index).get(record[index]));
            }
            results.add(row);
            crossRecord(crossArgs, record, crossArgs.size() - 1);
        }
        return results;
    }

    /**
     * @param sourceArgs
     * @param record
     * @param level
     */
    private static <T> void crossRecord(List<List<T>> sourceArgs, int[] record, int level) {
        record[level] = record[level] + 1;
        if (record[level] >= sourceArgs.get(level).size() && level > 0) {
            record[level] = 0;
            crossRecord(sourceArgs, record, level - 1);
        }
    }
}