Java 动态创建循环以在列表上迭代<；字符串>'；s

我有一个

List

的

List

，它是从外部API方法调用中获得的：

List<List<String>> outerList

---

这里，

outerList

有两个内部列表，因此我创建了两个for循环，用于显式迭代和连接。但是，在实时外部列表中，可以有任意数量的内部列表，如何动态循环所有内部循环并连接？

样本数据具有足够的变化来演示问题：

    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);

List outerList=new ArrayList（）；
List innerList1=新的ArrayList（）；
内部列表1.添加（“A”）；
内部列表1.添加（“B”）；
添加（innerList1）；
List innerList2=新的ArrayList（）；
内部列表2.添加（“X”）；
内部列表2.添加（“Y”）；
内部列表2.添加（“Z”）；
添加（innerList2）；
List innerList3=新的ArrayList（）；
内部列表3.添加（“P”）；
内部列表3.添加（“Q”）；
内部列表3.添加（“R”）；
添加（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;
        }
    }

int[]positions=newint[outerList.size（）]；
布尔值=真；
而（另一个）{
对于（int n=0；n

每次在主循环中，我都从每个内部列表打印一个项目。然后我推进计数器，从第一个开始。如果第一个内部列表的末尾没有出现这种情况，我们就可以再次打印了。但如果是这样的话，我将计数器设置为零，然后尝试推进第二个计数器，以此类推。如果它们全部归零，那么是时候退出了

---

这真的很像计数，只是每列都有不同的“基数”（而不是全部以10或2为基数或其他任何形式）。

这段代码适用于我：

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, "");
    }      
}

公共类测试
{  
公共静态void生成（LinkedList outerList，字符串输出）{
LinkedList=outerList.get（0）；
for（字符串str:list）{
LinkedList newOuter=新LinkedList（outerList）；
newOuter.remove（列表）；
如果（outerList.size（）>1）{
生成（newOuter，outPut+str）；
}否则{
系统输出打印项次（输出+str）；
}
}
}
公共静态void main（字符串[]args）
{
LinkedList outerList=新建LinkedList（）；
LinkedList list1=新建LinkedList（）；
LinkedList list2=新建LinkedList（）；
清单1.添加（“A”）；
清单1.添加（“B”）；
清单2.添加（“C”）；
清单2.添加（“D”）；
外部列表添加（列表1）；
添加（列表2）；
Test.generate（outerList，“”）；
}      
}

输出：

AC
广告
BC
屋宇署

---

不需要反省。只用于循环。也许可以发布到目前为止你的代码？会帮助人们准确地理解你在做什么。这是家庭作业吗？如果是，标记为家庭作业。三张单子怎么办？是否必须为每个列表选择一个元素？{A，B}{C，D}{E，F}组合的长度都是3个字符，还是也可以是1个字符，2个字符，依此类推？它们是无序的吗？AC=CA？@Daniel Earwicker我已经用示例代码更新了问题陈述。@stivlo这不是家庭作业。在我的当前项目中，客户机需要该逻辑。按照3个列表组合的列表顺序，每个列表中的一个元素将是ACE、ACF、ADE、ADF、BCE、BDF、BDE、BDF

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, "");
    }      
}