数组2D上的JAVA特定循环

我有这个阵列：

 int[][] multi = new int[][]{
              { 3, 4, 2},
              { 2, 2, 5 },
              { 1, 2 }
            };

我想打印每个单元格的产品。这很难解释，所以让我们看一些例子： 对于我的表格，我需要打印：

        6 //(3*2*1)
        12 //(3*2*2)
        6 //(3*2*1)
        12 //(3*2*2)
        15 //(3*5*1)
        30 //(3*5*2)
        8 //(4*2*1)
        16 //(4*2*2)
        8 //(4*2*1)
        16 //(4*2*2)
        20 //(4*5*1)
        40 //(4*5*2)

表的大小可以改变，我需要一个通用的东西

这是我的开始，但它没有做我需要的。这是一行一行的循环

   for (int i = 0; i<multi[0].length; i++) {
           for (int k = 0; k < multi.length; k++) {
                for (int l = 0; l < multi[k].length; l++ ) {
                    System.err.println(multi[k][l]);
                }    
           }   
    }

---

for（inti=0；ii）如果数组的维数不固定，则必须递归地执行该操作。。
我找到了
2D数组的动态维度代码

public class HelloWorld{
    static int[][] multi = new int[][]{
              { 3, 4, 2},
              { 2, 2, 5 },
              { 1, 2 }
    };
    static public void pattern(int row,int multip) {
        if(row >= multi.length) {
            System.out.println(multip);
            return ;
        }
        for(int i = 0; i<multi[row].length;i++) {
            multip*=multi[row][i];
            row+=1;
            pattern(row,multip);
            row-=1;
            multip/=multi[row][i];
        }
    }
    public static void main(String []args){
        pattern(0,1);
    }
}

公共类HelloWorld{
静态int[]multi=新int[]{
{ 3, 4, 2},
{ 2, 2, 5 },
{ 1, 2 }
};
静态公共无效模式（int行、int多行）{
如果（行>=multi.length）{
系统输出打印LN（多重）；
回来
}
对于（int i=0；i来说，不难解释是否使用数学术语，并且您需要的只是二维数组中的一组集合（即每一行）。
在这里解释笛卡尔积理论可能需要更长的时间（X是算子），但在实践中，您必须计算以下结果：

((multi[0] X multi[1]) X ...) X multi[n]

最后是一个二维数组，它有很多行，是每个集合的所有基数的乘积，每一行有很多元素，这些元素就是集合的数量（因为每个元组都有一个集合中的元素）

另一件事是元组是有序的，即集合的元素将在所有元组中处于相同的位置，例如，位置0的每个元组将有一个multi[0]元素

了解这些属性可以使用构造算法创建产品，该算法将第一个集合的元素放在结果集合的第一列中，重复它们所需的时间，然后继续下一个集合/下一列

最后，当你有笛卡尔乘积时，你可以做任何你想做的事情，例如，计算每行元素的乘积

public class CartesianProductProduct {

    public int[][] product(int[][] sets) {
        int cardinality = 1;
        for (int is = 0; is < sets.length; is++) cardinality *= sets[is].length;
        int[][] cartesianProduct = new int[cardinality][sets.length];
        int curCardinality = 1;
        for (int is = 0; is < sets.length; is++) {
            curCardinality *= sets[is].length;
            int repetition = cardinality / curCardinality;
            int ie = 0;
            for (int ic = 0; ic < cardinality; ic++) {
                cartesianProduct[ic][is] = sets[is][ie];
                if (repetition == 1) {
                    ie++;
                } else if ((ic + 1) % repetition == 0) {
                    ie++;
                }
                ie = ie == sets[is].length ? 0 : ie;
            }
        }
        return cartesianProduct;
    }

    public static void main(String[] args) {
        int[][] multi = new int[][]{
                {3, 4, 2},
                {2, 2, 5},
                {1, 2}
        };

        int[][] cartesianProduct = new CartesianProductProduct().product(multi);

        for (int i = 0; i < cartesianProduct.length; i++) {
            int prod = 1;
            String s = "";
            String sep = "";
            for (int k = 0; k < cartesianProduct[i].length; k++) {
                prod *= cartesianProduct[i][k];
                s = s + sep + cartesianProduct[i][k];
                sep = "*";
            }
            System.out.printf("%s //(%s)\n", prod, s);
        }
    }

}

公共类CartesianProduct产品{
公共int[][]产品（int[][]套）{
整数基数=1；
对于（int is=0；is
你能解释一下这些值是从哪里来的吗？例如，我不明白
multi
是如何产生
2,5,2
的。你需要按那个精确的顺序打印吗？它们都是每个单元格使用一个数字创建的组合。在这个示例中，它是反向打印的。我编辑了需要打印的内容，对不起，你从哪里得到这些表达式？不清楚您使用什么模式来生成乘积表达式。它不在列的下方或行的另一端。请澄清您希望从给定的表中进行什么计算。此外-您编写的代码块只是用于打印，而不是进行任何乘法运算，所以我看不出它与您提出的问题有什么关系？这是可以做到的使用迭代算法而不在循环内创建循环