在java中嵌套未定义数量的循环

我有一个java数组，长度可变（大约3-5）。现在我想将每个元素的值更改为另一个数组的每个可能元素（newvalues），以便所有组合

我通常只做一个循环中的一个循环，但在这种情况下，循环的数量是由数组的长度定义的。所以我感到奇怪的困惑。举个例子：

ArrayList<Integer> originalList = new ArrayList<Integer>(); \\has varying length
ArrayList<Integer> newvalues = new ArrayList<Integer>();

originalList.add(0);
originalList.add(0);

newvalues.add(1);
newvalues.add(2);
newvalues.add(3);

我想通过所有这些来执行操作：

1 1
1 2 
1 3
2 1 
2 2
2 3
...

我知道这会变成指数级的大，但由于原始数组不应该很大，所以应该可以

试试这个

static void loop(List<Integer> originalList, List<Integer> newvalues, int index) {
    if (index >= originalList.size())
        System.out.println(originalList);
    else {
        for (int i = 0; i < newvalues.size(); ++i) {
            originalList.set(index, newvalues.get(i));
            loop(originalList, newvalues, index + 1);
        }
    }
}

试试这个

static void loop(List<Integer> originalList, List<Integer> newvalues, int index) {
    if (index >= originalList.size())
        System.out.println(originalList);
    else {
        for (int i = 0; i < newvalues.size(); ++i) {
            originalList.set(index, newvalues.get(i));
            loop(originalList, newvalues, index + 1);
        }
    }
}

---

你确定你真的需要一个数组来排列所有的值吗？由大量数组和递归组成的答案所产生的问题几乎总是一个迹象，表明您对问题的想法是错误的

不管怎样，这是你要求的。当我看到这个，我有点畏缩，因为这个代码是多么危险。如果您将其用于长度超过微小尺寸的任何东西，那么将很快耗尽堆和堆栈空间

main()
{
    ArrayList<Integer> allowedValues = new ArrayList<>();
    allowedValues.add(0);
    allowedValues.add(1);
    allowedValues.add(2);
    allowedValues.add(3);
    int length = 2;

    ArrayList<ArrayList<Integer>> billionsAndBillions = new ArrayList<>();

    appendPermutations (allowedValues, billionsAndBillions, 2);
}

private List appendPermutation(List<Integer> values, List<List<Integer>> pile, int depth)
{
    depth --;
    if (pile.isEmpty())
    {       
        for (Integer value: values)
        {
            ArrayList<Integer> tmp = new ArrayList<>();
            tmp.add(value);
            pile.add(tmp);
        }
    }
    ArrayList<ArrayList<Integer>> newList = new ArrayList<>(); 
    for (List<Integer> list: pile)
    {       
        ArrayList<Integer> permutation = list.copy();
        for (Integer value: values)
        {
            permutation.add(value);
            newList.add(permutation);
        }
    }
    if (depth > 0)
    {
        newList = appendPermutation(values, newList, depth);
    }
    return newList;
}

main（）
{
ArrayList allowedValues=新的ArrayList（）；
允许值。添加（0）；
允许值。添加（1）；
允许值。添加（2）；
允许值。添加（3）；
整数长度=2；
ArrayList亿万沙亿=新建ArrayList（）；
附录排列（允许值，十亿和百万，2）；
}
私有列表置换（列表值、列表堆、整数深度）
{
深度--；
if（pile.isEmpty（））
{       
for（整数值：值）
{
ArrayList tmp=新的ArrayList（）；
tmp.增加值（价值）；
桩。添加（tmp）；
}
}
ArrayList newList=新的ArrayList（）；
用于（列表：桩）
{       
ArrayList排列=list.copy（）；
for（整数值：值）
{
排列。增加（价值）；
添加（排列）；
}
}
如果（深度>0）
{
newList=附录排列（值、newList、深度）；
}
返回newList；
}

您确定您真的需要一个包含所有值的数组吗？由大量数组和递归组成的答案所产生的问题几乎总是一个迹象，表明您对问题的想法是错误的

不管怎样，这是你要求的。当我看到这个，我有点畏缩，因为这个代码是多么危险。如果您将其用于长度超过微小尺寸的任何东西，那么将很快耗尽堆和堆栈空间

main()
{
    ArrayList<Integer> allowedValues = new ArrayList<>();
    allowedValues.add(0);
    allowedValues.add(1);
    allowedValues.add(2);
    allowedValues.add(3);
    int length = 2;

    ArrayList<ArrayList<Integer>> billionsAndBillions = new ArrayList<>();

    appendPermutations (allowedValues, billionsAndBillions, 2);
}

private List appendPermutation(List<Integer> values, List<List<Integer>> pile, int depth)
{
    depth --;
    if (pile.isEmpty())
    {       
        for (Integer value: values)
        {
            ArrayList<Integer> tmp = new ArrayList<>();
            tmp.add(value);
            pile.add(tmp);
        }
    }
    ArrayList<ArrayList<Integer>> newList = new ArrayList<>(); 
    for (List<Integer> list: pile)
    {       
        ArrayList<Integer> permutation = list.copy();
        for (Integer value: values)
        {
            permutation.add(value);
            newList.add(permutation);
        }
    }
    if (depth > 0)
    {
        newList = appendPermutation(values, newList, depth);
    }
    return newList;
}

main（）
{
ArrayList allowedValues=新的ArrayList（）；
允许值。添加（0）；
允许值。添加（1）；
允许值。添加（2）；
允许值。添加（3）；
整数长度=2；
ArrayList亿万沙亿=新建ArrayList（）；
附录排列（允许值，十亿和百万，2）；
}
私有列表置换（列表值、列表堆、整数深度）
{
深度--；
if（pile.isEmpty（））
{       
for（整数值：值）
{
ArrayList tmp=新的ArrayList（）；
tmp.增加值（价值）；
桩。添加（tmp）；
}
}
ArrayList newList=新的ArrayList（）；
用于（列表：桩）
{       
ArrayList排列=list.copy（）；
for（整数值：值）
{
排列。增加（价值）；
添加（排列）；
}
}
如果（深度>0）
{
newList=附录排列（值、newList、深度）；
}
返回newList；
}

这似乎是一个可以通过递归解决的问题。但是，如果您将第一个数组的值切换为第二个数组中所有值的排列，为什么创建的数组有3个元素而不是两个？Jim W，您是对的，我的错。我已经更新了这个问题。克拉斯软特：啊，复发，这很有趣。我有点忘记了，我觉得这样做可能是不好的做法。下一个问题，如果你在第一个数组中放置0，1，0会只出现在创建的数组的第一个位置，还是同时出现在这两个数组中？如果要将0、1、2、3放入数组中，并且希望其长度为2，为什么不省略原始数组并指定元素的长度和允许值？嗨，Jim W。我很困惑，因为在我的实际代码中，当前值包含在新值中。为了简化它，我只是删除了这里的零。这似乎是一个可以通过递归解决的问题。但是如果你将第一个数组的值转换为第二个数组中所有值的排列，为什么创建的数组有3个元素而不是两个？Jim W，你是对的，我的错。我已经更新了这个问题。克拉斯软特：啊，复发，这很有趣。我有点忘记了，我觉得这样做可能是不好的做法。下一个问题，如果你在第一个数组中放置0，1，0会只出现在创建的数组的第一个位置，还是同时出现在这两个数组中？如果要将0、1、2、3放入数组中，并且希望其长度为2，为什么不省略原始数组并指定元素的长度和允许值？嗨，Jim W。我很困惑，因为在我的实际代码中，当前值包含在新值中。为了简化它，我刚刚删除了这里的零。非常感谢。为了安全起见，我实际上将列表大小限制为两个。这种类型的编程让我感到紧张：）非常感谢。为了安全起见，我实际上将列表大小限制为两个。这种类型的编程让我感到紧张：）

main()
{
    ArrayList<Integer> allowedValues = new ArrayList<>();
    allowedValues.add(0);
    allowedValues.add(1);
    allowedValues.add(2);
    allowedValues.add(3);
    int length = 2;

    ArrayList<ArrayList<Integer>> billionsAndBillions = new ArrayList<>();

    appendPermutations (allowedValues, billionsAndBillions, 2);
}

private List appendPermutation(List<Integer> values, List<List<Integer>> pile, int depth)
{
    depth --;
    if (pile.isEmpty())
    {       
        for (Integer value: values)
        {
            ArrayList<Integer> tmp = new ArrayList<>();
            tmp.add(value);
            pile.add(tmp);
        }
    }
    ArrayList<ArrayList<Integer>> newList = new ArrayList<>(); 
    for (List<Integer> list: pile)
    {       
        ArrayList<Integer> permutation = list.copy();
        for (Integer value: values)
        {
            permutation.add(value);
            newList.add(permutation);
        }
    }
    if (depth > 0)
    {
        newList = appendPermutation(values, newList, depth);
    }
    return newList;
}