使用递归实现多个集合取不同元素生成多种组合

使用递归实现读个集合取不同元素生成多种组合

多种组合其实有很多种办法，递归是一种，还有我知道的笛卡尔积也是能够来实现这种需求

软件使用：idea
jdk版本：1.8

递归

递归：你打开面前这扇门，看到屋里面还有一扇门（这门可能跟前面打开的门一样大小（静），
        也可能门小了些（动）），你走过去，发现手中的钥匙还可以打开它，你推开门，发现里面还有一扇门，
        你继续打开，。。。， 若干次之后，你打开面前一扇门，发现只有一间屋子，没有门了。 你开始原路返回，
        每走回一间屋子，你数一次，走到入口的时候，你可以回答出你到底用这钥匙开了几扇门。

循环：你打开面前这扇门，看到屋里面还有一扇门，（这门可能跟前面打开的门一样大小（静），
       	   也可能门小了些（动）），你走过去，发现手中的钥匙还可以打开它，你推开门，发现里面还有一扇门，
       	   （前面门如果一样，这门也是一样，第二扇门如果相比第一扇门变小了，这扇门也比第二扇门变小了
       	   （动静如一，要么没有变化，要么同样的变化）），你继续打开这扇门，。。。，一直这样走下去。
       	    入口处的人始终等不到你回去告诉他答案。

废话不多说直接上核心代码：

class fun{
    public static <T> List<List<T>>getDescartes (List<List<T>>list){
        List<List<T>>returnList = new ArrayList<>();
        descartesRecursive(list,0,returnList,new ArrayList<>());
        return returnList;
    }   
    /**
     * 使用递归实现
     * @param originList 原始list
     * @param position   集合中位置
     * @param returnList 返回组装集合
     * @param cacheList  临时集合
     */
    private static <T> void descartesRecursive(List<List<T>>originList,int position,List<List<T>>returnList,List<T>cacheList){
        List<T> originChildList = originList.get(position);
        for (int i = 0; i<originChildList.size();i++){
            List<T> cacheChildList = (i==originChildList.size()-1)?cacheList:new ArrayList<>(cacheList);
            cacheChildList.add(originChildList.get(i));
            if(position==originList.size()-1){
                returnList.add(cacheChildList);
                continue;
            }
            descartesRecursive(originList,position+1,returnList,cacheChildList);
        }
    }
}
    ```

然后我们进行方法调用测试

 public static void main(String[] args) {
        List<String>oneList = Stream.of("1","2","3").collect(Collectors.toList());
        List<String>twoList = Stream.of("a","b","c").collect(Collectors.toList());
        List<String>threeList = Stream.of("@","#","$").collect(Collectors.toList());
        List<String>fourList = Stream.of("/","*","-").collect(Collectors.toList());
        List<List<String>>list = new ArrayList<>();
        list.add(oneList);
        list.add(twoList);
        list.add(threeList);
        list.add(fourList);
        List<List<String>>returnList = fun.getDescartes(list);
        returnList.forEach(System.err::println);
    }

接着我们查看结果：

[1, a, @, /]
[1, a, @, *]
[1, a, @, -]
[1, a, #, /]
[1, a, #, *]
[1, a, #, -]
[1, a, $, /]
[1, a, $, *]
[1, a, $, -]
[1, b, @, /]
[1, b, @, *]
[1, b, @, -]
[1, b, #, /]
[1, b, #, *]
[1, b, #, -]

以上就是整个代码输出的结果，希望对读者能够提供帮助。这是我最欣慰的结果。

我就是我，还在代码路途前走的小猿。