Java 数组列表笛卡尔积元素的正确顺序

我试图根据以下答案生成未知数量的数组列表（固定类型）的笛卡尔积：。但是我发现了一些奇怪的事情。笛卡尔积总是以相反的顺序给出。例如，如果A和B是两个列表，则在笛卡尔对中首先给出B的元素，然后给出A的元素。可能的原因是什么？如何解决这个问题？最初的回答者说，在笛卡尔积中，顺序并不重要。但我认为，在制作笛卡尔积时，排序是最主要的，尤其是当每一组表示平面坐标时

修改代码：

私有静态集合cartesianProduct（ArrayList集合）{
if（sets.size（）<2）
抛出新的IllegalArgumentException(
“不能有少于两组的产品（got）”+
set.size（）+“”）；
返回_cartesianProduct（0套）；
}
私有静态集合_cartesianProduct（int索引、ArrayList集合）{
Set ret=new HashSet（）；
if（index==sets.size（））{
ret.add（新的ArrayList（））；
}否则{
for（双对象：set.get（索引））{
对于（ArrayList集合：_cartesianProduct（索引+1，集合））{
集合。添加（obj）；
重新添加（设置）；
}
}
}
返回ret；
}

输出：

ArrayList<Double> l1 = new ArrayList<>(Arrays.asList(1.0, 2.0));
ArrayList<Double> l2 = new ArrayList<>(Arrays.asList(4.0, 5.0));
ArrayList<ArrayList<Double>> l = new ArrayList<>(Arrays.asList(l1, l2));
Set<ArrayList<Double>> a = cartesianProduct(l);

// a = [[4.0, 1.0], [4.0, 2.0], [5.0, 1.0], [5.0, 2.0]]

ArrayList l1=新的ArrayList（Arrays.asList（1.0,2.0））；
ArrayList l2=新的ArrayList（Arrays.asList（4.0,5.0））；
ArrayList l=新的ArrayList（Arrays.asList（l1，l2））；
集合a=卡特尔产品（l）；
//a=[[4.0,1.0]、[4.0,2.0]、[5.0,1.0]、[5.0,2.0]]

发生这种情况是因为递归。索引最初为0，因此在（ArrayList集合：_cartesianProduct（索引+1，集合））的

行{

，您的代码再次调用

cartesianProduct

，索引为1。它再次到达该行，并调用

cartesianProduct

，索引为2。当它位于索引为2时，它到达其基本大小写，并返回一个带有空

数组列表的集合

然后返回到stackframe，其中index=1（记住，
obj
是4.0，因为
set.get（1）
是包含4和6的数组列表）。它将
set.get（index）
中的所有双精度相加（这里是4.0和6.0）然后到达foreach循环的末尾并返回集合，该集合现在有两个ArrayList，一个包含4.0，另一个包含6.0

同样的情况也发生在index=0时，因此第一个列表（或集合）的元素被添加到第二个列表的元素之后。这就是为什么会得到相反的结果

要解决这个问题，您可以每次递减索引，从sets.size（）到0，而不是相反。要反转索引，您也可以对结果中的每个集合调用Collections.reverse（）

//通过递减索引进行修复
私有静态集合cartesianProduct（ArrayList集合）{
if（sets.size（）<2）
抛出新的IllegalArgumentException(
“不能有少于两组的产品（得到“+sets.size（）+”）；
//一定要从“集合”的末尾开始，这样你就可以按一个集合往下走
返回cartesianProduct（sets.size（）-1，sets）；
}
私有静态集合cartesianProduct（int索引、ArrayList集合）{
Set ret=new HashSet（）；
//计数到0而不是集合ArrayList的末尾
如果（指数<0）{
ret.add（新的ArrayList（））；
}否则{
for（双对象：set.get（索引））{
对于（ArrayList集合：cartesianProduct（索引-1，集合））{
集合。添加（obj）；
重新添加（设置）；
}
}
}
返回ret；
}

//使用Collections.reverse的备选答案
私有静态集合cartesianProduct（ArrayList集合）{
if（sets.size（）<2）
抛出新的IllegalArgumentException(
“不能有少于两组的产品（得到“+sets.size（）+”）；
//这基本上会遍历集合集并反转每个ArrayList
返回cartesianProduct（0，sets）.stream（）.map（Collections:：reverse）.collection（Collectors.toSet（））；
}
发生这种情况是因为递归。索引最初是0，所以在第
行（ArrayList集合：_cartesianProduct（索引+1，集合））{
，您的代码再次调用
cartesianProduct
，索引为1。它再次到达该行，并调用
cartesianProduct
，索引为2。当它位于索引为2时，它到达其基本大小写，并返回一个带有空
数组列表的集合

然后返回到stackframe，其中index=1（记住，
obj
是4.0，因为
set.get（1）
是包含4和6的数组列表）。它将
set.get（index）
中的所有双精度相加（这里是4.0和6.0）然后到达foreach循环的末尾并返回集合，该集合现在有两个ArrayList，一个包含4.0，另一个包含6.0

同样的情况也发生在index=0时，因此第一个列表（或集合）的元素被添加到第二个列表的元素之后。这就是为什么会得到相反的结果

要解决这个问题，您可以每次递减索引，从sets.size（）到0，而不是相反。要反转索引，您也可以对结果中的每个集合调用Collections.reverse（）

//通过递减索引进行修复
私有静态集合cartesianProduct（ArrayList集合）{
if（sets.size（）<2）
抛出新的IllegalArgumentException(
“不能有少于两组的产品（得到“+sets.size（）+”）；
//一定要从“集合”的末尾开始，这样你就可以按一个集合往下走
返回cartesianProduct（sets.size（）-1，sets）；
}
私有静态集合cartesianProduct（int索引、ArrayList集合）{
Set ret=new HashSet（）；
//计数到0而不是集合ArrayList的末尾
如果（指数<0）{
ret.add（新的ArrayList（））；
}否则{
for（双对象：set.get（索引））{
对于（ArrayList集合：cartesianProduct（索引-1，集合））
//Alternative answer using Collections.reverse
private static Set<ArrayList<Double>> cartesianProduct(ArrayList<ArrayList<Double>> sets) {
    if (sets.size() < 2)
        throw new IllegalArgumentException(
                "Can't have a product of fewer than two sets (got " + sets.size() + ")");
    //This basically goes through the set of sets and reverses each ArrayList
    return cartesianProduct(0, sets).stream().map(Collections::reverse).collect(Collectors.toSet());
}

set.add(0, obj);

    return _cartesianProduct(sets.size() - 1, sets);
...
            for (ArrayList<Double> set : _cartesianProduct(index - 1, sets)) {