java递归使用所有可能的组合创建列表列表

问题是：我有很多清单。首先，我只需选择字符串列表，让我们选择两个简单的列表：

[A，B，C]

和

[W，X，Y，Z]

我需要填写我的

排列结果

，这是ArrayList的ArrayList，以便：

permutationResult  = [[A, W], [A, X], [A, Y], [A, Z], [B, W], [B, X], [B, Y], [B, Z], [C, W], [C, X], [C, Y], [C, Z]]

我设法通过递归获得组合，但当我尝试将结果存储在我的

排列结果

列表中时，该列表似乎被完全删除，每次都被最后一次排列所取代。我复制下面的代码和代码运行的结果。我添加了一些

System.out.println

，以便注意哪里出了问题，但我不知道该怎么做，欢迎提供任何帮助。 先谢谢你。（本代码的执行情况也如下所示）

---

下面的递归解决方案怎么样？ 您可以使用

Set

删除重复项。 这里的想法模仿了两个for循环。迭代第一个列表

go(a.subList(1, a.size()), b, acc);

然后通过第二个

go(a, b.subList(1, b.size()), acc);

请记住，Java很少被认为是递归问题的首选语言

public class Perm {

    public List<List<String>> perm(List<String> a, List<String> b) {
        Set<List<String>> acc = new HashSet<>();
        go(a, b, acc);
        return new LinkedList<>(acc);
    }

    private void go(List<String> a, List<String> b, Set<List<String>> acc) {
        if (a.size() == 0 || b.size() == 0) {
            return;
        }
        List<String> aa = new LinkedList<>();
        aa.add(a.get(0));
        aa.add(b.get(0));
        acc.add(aa);

        go(a.subList(1, a.size()), b, acc);
        go(a, b.subList(1, b.size()), acc);
    }

    public static void main(String[] args) {
        List<String> a = new LinkedList<>();
        a.add("X");
        a.add("Y");
        a.add("Z");

        List<String> b = new LinkedList<>();
        b.add("A");
        b.add("B");
        b.add("C");
        b.add("D");
        System.out.println(new Perm().perm(a, b));
    }
}

公共类Perm{
公共列表perm（列表a、列表b）{
Set acc=new HashSet（）；
go（a、b、acc）；
返回新的LinkedList（acc）；
}
专用作废go（列表a、列表b、设置acc）{
如果（a.size（）==0 | | b.size（）==0）{
返回；
}
List aa=新的LinkedList（）；
aa.添加（a.get（0））；
aa.添加（b.get（0））；
acc.add（aa）；
go（a.子列表（1，a.大小（）），b，acc）；
go（a，b.子列表（1，b.大小（）），acc）；
}
公共静态void main（字符串[]args）{
列表a=新的LinkedList（）；
a、 添加（“X”）；
a、 添加（“Y”）；
a、 添加（“Z”）；
列表b=新的LinkedList（）；
b、 添加（“A”）；
b、 添加（“b”）；
b、 添加（“C”）；
b、 添加（“D”）；
System.out.println（new Perm（）.Perm（a，b））；
}
}

好吧，我想我明白了！ 如果我们有一个或多个列表，以下是我的问题的答案： 谢谢你昨天的及时回复。 PS：这是我第一次在这个平台上发布问题，如果我不知道如何正确显示我的代码，我深表歉意：）

公共类TestObject{
静态ArrayList排列（对象值、ArrayList所有列表）{
ArrayList PermuteOnlist；
ArrayList permuteSeveralLists=新的ArrayList（）；
如果（所有列表.size（）！=1）{
for（int i=0；i

谢谢您的快速回答！然而，这种方法只需要2个列表，我的问题的目的是处理动态数量的列表。有什么见解吗？

go(a, b.subList(1, b.size()), acc);

public class Perm {

    public List<List<String>> perm(List<String> a, List<String> b) {
        Set<List<String>> acc = new HashSet<>();
        go(a, b, acc);
        return new LinkedList<>(acc);
    }

    private void go(List<String> a, List<String> b, Set<List<String>> acc) {
        if (a.size() == 0 || b.size() == 0) {
            return;
        }
        List<String> aa = new LinkedList<>();
        aa.add(a.get(0));
        aa.add(b.get(0));
        acc.add(aa);

        go(a.subList(1, a.size()), b, acc);
        go(a, b.subList(1, b.size()), acc);
    }

    public static void main(String[] args) {
        List<String> a = new LinkedList<>();
        a.add("X");
        a.add("Y");
        a.add("Z");

        List<String> b = new LinkedList<>();
        b.add("A");
        b.add("B");
        b.add("C");
        b.add("D");
        System.out.println(new Perm().perm(a, b));
    }
}

public class TestObject {

    static ArrayList<ArrayList<Object>> permute(Object val, ArrayList<ArrayList<Object>> all_Lists) {

        ArrayList<ArrayList<Object>> permuteOneList;
        ArrayList<ArrayList<Object>> permuteSeveralLists = new ArrayList<ArrayList<Object>>();

        if (all_Lists.size() != 1) {
            for (int i = 0; i < all_Lists.get(0).size(); i++) {
                permuteOneList = permute(all_Lists.get(0).get(i), new ArrayList(all_Lists.subList(1, all_Lists.size())));
                if (!val.equals("")) {
                    ArrayList<Object> comb;
                    for (int j = 0; j < permuteOneList.size(); j++) {
                        comb = permuteOneList.get(j);
                        comb.add(0, val);
                        permuteSeveralLists.add(comb);
                    }
                } else {
                    permuteSeveralLists.addAll(permuteOneList);
                }
            }
            return permuteSeveralLists;
        } 
        else {
            permuteOneList = new ArrayList<ArrayList<Object>>();
            for (int i = 0; i < all_Lists.get(0).size(); i++) {
                ArrayList<Object> comb = new ArrayList<Object>();
                if (val ==""){
                    comb.add(all_Lists.get(0).get(i));
                    permuteOneList.add(comb);
                }
                else {
                    comb.add(val);
                    comb.add(all_Lists.get(0).get(i));
                    permuteOneList.add(comb);
                }
            }
            return permuteOneList;
        }

    }

    public static void main(String[] args) {
        ArrayList<Object> l1 = new ArrayList<Object>();
        l1.add("a");
        l1.add("b");
        l1.add("c");
        l1.add("d");
        ArrayList<Object> l2 = new ArrayList<Object>();
        l2.add("w");
        l2.add("x");
        l2.add("y");
        l2.add("z");
        ArrayList<ArrayList<Object>> all_Lists = new ArrayList<ArrayList<Object>>();

        ArrayList<Object> l3 = new ArrayList<Object>();
        l3.add("1");
        l3.add("2");
        l3.add("3");
        all_Lists.add(l1);
        all_Lists.add(l2);
        all_Lists.add(l3);
        ArrayList<ArrayList<Object>> permt = permute("", all_Lists);
        System.out.println("size : " + permt.size());
        System.out.println("permutation is : " + permt);
    }

}