java做笛卡尔积的两种方式

第一中，可以看做是横向的，即一个一个list遍历，遍历最后一个list时，才能获取到笛卡尔积

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

/**
 * 算法工具类
 * 
 * Project Name：erp-procurement-util
 * ClassName：ArithmeticUtils
 * Description：
 * @date: 2019年7月20日 上午11:57:49
 * note:
 *
 */
public class ArithmeticUtils {

	/**
     * 获取N个集合的笛卡尔积
     * <p/>
     * 假如传入的字符串List为：[[1, 2, 3], [5, 6], [7, 8]]
     * a=[1, 2, 3]
     * b=[5, 6]
     * c=[7, 8]
     * 其大小分别为：a_length=3，b_length=2，c_length=2，
     * 目标list的总大小为：totalSize=3*2*2 = 12
     * 对每个子集a，b，c，进行循环次数=总记录数/(元素个数*后续集合的笛卡尔积个数)
     * 对a中的每个元素循环次数=总记录数/(元素个数*后续集合的笛卡尔积个数)=12/(3*4)=1次，每个元素每次循环打印次数：后续集合的笛卡尔积个数=2*2个
     * 对b中的每个元素循环次数=总记录数/(元素个数*后续集合的笛卡尔积个数)=12/(2*2)=3次，每个元素每次循环打印次数：后续集合的笛卡尔积个数=2个
     * 对c中的每个元素循环次数=总记录数/(元素个数*后续集合的笛卡尔积个数)=12/(2*1)=6次，每个元素每次循环打印次数：后续集合的笛卡尔积个数=1个
     * <p/>
     * 运行结果：
     * [[1, 2, 3], [5, 6], [7, 8]]
     * 1,5,7,
     * 1,5,8,
     * 1,6,7,
     * 1,6,8,
     * 2,5,7,
     * 2,5,8,
     * 2,6,7,
     * 2,6,8,
     * 3,5,7,
     * 3,5,8,
     * 3,6,7,
     * 3,6,8]
     * <p/>
     * 从结果中可以看到：
     * a中的每个元素每个元素循环1次，每次打印4个
     * b中的每个元素每个元素循环3次，每次打印2个
     * c中的每个元素每个元素循环6次，每次打印1个
     *
     * @param args
     * @return 结果用逗号分隔
     */
	public static List<List<String>> descartes(List<List<String>> strs) {
        int total = 1;
        for (int i = 0; i < strs.size(); i++) {
            total *= strs.get(i).size();
        }
        String[] myresult = new String[total];
        int now = 1;
        //每个元素每次循环打印个数
        int itemLoopNum = 1;
        //每个元素循环的总次数
        int loopPerItem = 1;
        for (int i = 0; i < strs.size(); i++) {
            List<String> temp = strs.get(i);
            now = now * temp.size();
            //目标数组的索引值
            int index = 0;
            int currentSize = temp.size();
            itemLoopNum = total / now;
            loopPerItem = total / (itemLoopNum * currentSize);
            int myindex = 0;
            for (int j = 0; j < temp.size(); j++) {

                //每个元素循环的总次数
                for (int k = 0; k < loopPerItem; k++) {
                    if (myindex == temp.size())
                        myindex = 0;
                    //每个元素每次循环打印个数
                    for (int m = 0; m < itemLoopNum; m++) {
                        myresult[index] = (myresult[index] == null ? "" : myresult[index] + ",") + temp.get(myindex);
                        index++;
                    }
                    myindex++;

                }
            }
        }
        List<String> asList = Arrays.asList(myresult);
        List<List<String>> resList = new ArrayList<>();
        for (String str : asList) {
        	resList.add(new ArrayList<>(Arrays.asList(str.split(","))));
		}
        return resList;
    }
	
	
	public static void main(String[] args) {
        String str = "1,200,2,3==3,23,232==33,3,1==1,3";
        String[] list = str.split("==");
        List<List<String>> strs = new ArrayList<>();
        for (int i = 0; i < list.length; i++) {
            strs.add(Arrays.asList(list[i].split(",")));
        }
        System.out.println(strs);
        
        List<List<String>> result = descartes(strs);
        System.out.println(result);

    }
}

第二种可以看做是纵向，即遍历所有的list，就得到一个一个的结果

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

/**
 * @Description:
 * @ClassName: DiKaErDiGui
 * @CreateDate: 2020-01-13 16:13
 */
public class DiKaErDiGui {

    public static void main(String[] args) {
        List<List<String>> listData = new ArrayList<>();
        String str = "1,200,2,3==3,23,232==33,3,1==1,3";
        String[] split = str.split("==");
        for (String s : split) {
            listData.add( Arrays.asList(s.split(",")));
        }

        System.out.println("集合为:" + listData);
        List<List<String>> lisReturn = getDescartes(listData);
        System.out.println("笛卡尔积：" + lisReturn);
    }

    private static <T> List<List<T>> getDescartes(List<List<T>> list) {
        List<List<T>> returnList = new ArrayList<>();
        descartesRecursive(list, 0, returnList, new ArrayList<T>());
        return returnList;
    }

    /**
     * 递归实现
     * 原理：从原始list的0开始依次遍历到最后
     *
     * @param originalList 原始list
     * @param position     当前递归在原始list的position
     * @param returnList   返回结果
     * @param cacheList    临时保存的list
     */
    private static <T> void descartesRecursive(List<List<T>> originalList, int position, List<List<T>> returnList, List<T> cacheList) {
        List<T> originalItemList = originalList.get(position);
        for (int i = 0; i < originalItemList.size(); i++) {
            //最后一个复用cacheList，节省内存
            List<T> childCacheList = (i == originalItemList.size() - 1) ? cacheList : new ArrayList<>(cacheList);
            childCacheList.add(originalItemList.get(i));
            if (position == originalList.size() - 1) {//遍历到最后退出递归
                returnList.add(childCacheList);
                continue;
            }
            descartesRecursive(originalList, position + 1, returnList, childCacheList);
        }
    }
}