Question

我有一个List的{{1}}来自外部API方法调用：

List<String>

我必须通过按照它们在外部列表中的顺序连接每个列表中的字符串来创建唯一的键组合。

示例：如果外部列表有2个内部列表，例如list1：{“A”，“B”}和list2：{“C”，“D”}。然后可能的唯一组合将是AC，AD，BC和BD。

但问题是List<List<String>> outerList大小是动态的，它可以包含任意数量的内部列表。如果内部列表编号是固定的，那么我可以编写循环并创建组合。

我正在考虑使用反射，递归等方向，但到目前为止还没能解决它。

outerList

这里public static void main(String[] args) { List<List<String>> outerList = new ArrayList<List<String>>(); List<String> list1 = new ArrayList<String>(); list1.add("A"); list1.add("B"); List<String> list2 = new ArrayList<String>(); list2.add("C"); list2.add("D"); outerList.add(list1); outerList.add(list2); for(String s1: list1) { for(String s2: list2) { System.out.println(s1+s2); } } }有2个内部列表，所以我创建了2个for循环显式迭代和连接。但实时outerList可以有任意数量的内部列表，如何循环遍历所有内部循环并连接？

Answer 1

此代码适用于我：

public class Test
{  

    public static void generate(LinkedList<LinkedList<String>> outerList, String outPut) {
        LinkedList<String> list = outerList.get(0);

        for(String str : list) {
            LinkedList<LinkedList<String>> newOuter = new LinkedList<LinkedList<String>>(outerList);
            newOuter.remove(list);

            if(outerList.size() > 1) {
                generate(newOuter, outPut+str);
             } else {
               System.out.println(outPut+str);
             }
        }
    }

    public static void main(String[] args) 
    {
        LinkedList<LinkedList<String>> outerList = new LinkedList<LinkedList<String>>();

        LinkedList<String> list1 = new LinkedList<String>();
        LinkedList<String> list2 = new LinkedList<String>();

        list1.add("A");
        list1.add("B");

        list2.add("C");
        list2.add("D");

        outerList.add(list1);
        outerList.add(list2);

        Test.generate(outerList, "");
    }      
}

输出：

AC
  AD
  BC
  BD

Answer 2

示例数据具有足够的变化来证明问题：

    List<List<String>> outerList = new ArrayList<List<String>>();

    List<String> innerList1 = new ArrayList<String>();
    innerList1.add("A");
    innerList1.add("B");
    outerList.add(innerList1);

    List<String> innerList2 = new ArrayList<String>();
    innerList2.add("X");
    innerList2.add("Y");
    innerList2.add("Z");
    outerList.add(innerList2);

    List<String> innerList3 = new ArrayList<String>();
    innerList3.add("P");
    innerList3.add("Q");
    innerList3.add("R");
    outerList.add(innerList3);

保留一系列计数器：

    int[] positions = new int[outerList.size()];

    boolean another = true;
    while (another) {
        for (int n = 0; n < outerList.size(); n++) {
            System.out.print(outerList.get(n).get(positions[n]));
        }
        System.out.println();

        another = false;
        for (int c = 0; c < outerList.size(); c++) {
            positions[c]++;
            if (positions[c] < outerList.get(c).size()) {
                another = true;
                break;
            }
            positions[c] = 0;
        }
    }

每次在主循环中，我都会从每个内部列表中打印一个项目。然后我从第一个开始推进计数器。如果这不在第一个内部列表的末尾，我们就可以再次打印了。但如果确实如此，我将该计数器设置为零，并尝试推进第二个，依此类推。如果它们都回绕到零，那么就该退出了。

这真的就像计数一样，除了每个列都有不同的“基础”（而不是所有的基数都是10或2或者其他）。

动态创建循环以迭代List of List <string>的</string>

2 个答案: