Java动态嵌套循环

我有一个包含可变长度字符串列表的映射。e、 g

Map<String, List<String> map = new HashMap<>();
map.put("key", "key1, key2);
map.put("name", "name1, name2, name3");
map.put("code", "code1, code2");

---

但问题是这是用3个for循环硬编码的，但我期望的是支持任意数量的变量。非常感谢及时的帮助

我在下面提供了一个使用递归的示例解决方案

在这个例子中，我们有3个列表，包含rep.3,4,4个元素；程序打印所有3*4*4=48个元素组合

从一个空组合（一个空列表）开始，在每个步骤（i）中，我们获取当前元组的N=list（i）.size（）副本，将值（j）=list（i）[j]添加到第j个新元组（对于j=1..N），然后递归。 当i=list.size时，元组就完成了，我们可以使用它（例如打印出来）。 （可以使用构造函数复制列表）

包装样品；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.Map；
导入java.util.Map.Entry；
导入java.util.TreeMap；
导入java.util.function.Consumer；
公共类样本组合{
公共静态void main（字符串[]args）{
Map Map=newtreemap（）；
map.put（“x”，Arrays.asList（“a”，“b”，“c”）；
map.put（“y”，数组.asList（“0”、“1”、“2”、“3”）；
map.put（“z”，Arrays.asList（“！”、“-”、“=”、“%”）；
ArrayList entries=新的ArrayList（map.entrySet（））；
系统输出打印项次（条目）；
印刷品组合（条目）；
}
专用静态void打印组合（列表条目）{
消费者cons=list->System.out.println（列表）；
generateComb（条目、cons、0、新LinkedList（））；
}
私有静态void generateComb（列表项，
消费者消费者，整数索引，列表当前元组）{
/*
*终端条件：如果i==entries.size，则元组已完成
*消耗它并返回
*/
if（index==entries.size（））{
consumer.accept（currentTuple）；
}
否则{
/*
*从第i个列表中获取所有元素，生成N个新元组并递归
*/
List elems=entries.get（index.getValue（）；
用于（字符串元素：元素）{
//复制当前元组
LinkedList newTuple=新LinkedList（currentTuple）；
新增（元素）；
generateComb（条目、消费者、索引+1、新元组）；
}
}
}
}

下面的代码片段解决了这个问题

    protected static void traverseParam(Map<String, List<String>> paramLists, int level, Map<String, String> paramMap) {
                if (level == paramLists.size()) {
                   //contains of all combinations
                    System.out.println(StringUtils.join(paramMap.values(), ", "));
                } else {
                    String paramKey = (String) paramLists.keySet().toArray()[level];
                    List<String> paramValues = (List<String>) paramLists.values().toArray()[level];
                    for (String paramValue : paramValues) {
                        paramMap.put(paramKey, paramValue);
                        //Recursively calls until all params are processed
                        traverseParam(paramLists, level + 1, paramMap);
                    }
                }
            }

受保护的静态void transverseParam（映射参数列表、int级别、映射参数映射）{
if（level==paramLists.size（））{
//包含所有组合的名称
System.out.println（StringUtils.join（paramMap.values（），“，”）；
}否则{
字符串paramKey=（字符串）paramLists.keySet（）.toArray（）[level]；
List paramValues=（List）paramLists.values（）.toArray（）[level]；
for（字符串参数值：参数值）{
paramMap.put（paramKey，paramValue）；
//递归调用，直到处理完所有参数
traverseParam（参数列表，级别+1，参数映射）；
}
}
}

现在像下面那样调用这个方法

Map<String, List<String> map = new HashMap<>();
map.put("key", "key1, key2);
map.put("name", "name1, name2, name3");
map.put("code", "code1, code2");
//Start with 1st parameter, and pass 
//an empty LinkedHashMap and all entries will be added to this map.
traverseParam(map, 0, new LinkedHashMap<String, String>());

---

map此代码不生成置换。完成后，
值
映射中您希望/期望的内容是什么？
package sample;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
import java.util.function.Consumer;

public class SampleCombinations {

  public static void main(String[] args) {

    Map<String, List<String>> map = new TreeMap<>();
    map.put("x", Arrays.asList("a", "b", "c"));
    map.put("y", Arrays.asList("0", "1", "2", "3"));
    map.put("z", Arrays.asList("!", "-", "=", "%"));

    ArrayList<Entry<String, List<String>>> entries = new ArrayList<>(map.entrySet());

    System.out.println(entries);
    printCombinations(entries);
  }

  private static void printCombinations(List<Entry<String, List<String>>> entries) {
    Consumer<List<String>> cons = list -> System.out.println(list);
    generateComb(entries, cons, 0, new LinkedList<>());
  }

  private static void generateComb(List<Entry<String, List<String>>> entries,
      Consumer<List<String>> consumer, int index, List<String> currentTuple) {

    /*
     * terminal condition: if i==entries.size the tuple is complete
     * consume it and return
     */
    if(index==entries.size()) {
      consumer.accept(currentTuple);
    }
    else {
      /*
       * get all elements from the i-th list, generate N new tuples and recurse
       */
      List<String> elems = entries.get(index).getValue();
      for (String elem:elems) {
        // copy the current tuple
        LinkedList<String> newTuple = new LinkedList<>(currentTuple);
        newTuple.add(elem);
        generateComb(entries, consumer, index+1, newTuple);
      }
    }
  }
}

    protected static void traverseParam(Map<String, List<String>> paramLists, int level, Map<String, String> paramMap) {
                if (level == paramLists.size()) {
                   //contains of all combinations
                    System.out.println(StringUtils.join(paramMap.values(), ", "));
                } else {
                    String paramKey = (String) paramLists.keySet().toArray()[level];
                    List<String> paramValues = (List<String>) paramLists.values().toArray()[level];
                    for (String paramValue : paramValues) {
                        paramMap.put(paramKey, paramValue);
                        //Recursively calls until all params are processed
                        traverseParam(paramLists, level + 1, paramMap);
                    }
                }
            }

Map<String, List<String> map = new HashMap<>();
map.put("key", "key1, key2);
map.put("name", "name1, name2, name3");
map.put("code", "code1, code2");
//Start with 1st parameter, and pass 
//an empty LinkedHashMap and all entries will be added to this map.
traverseParam(map, 0, new LinkedHashMap<String, String>());