如何在java中以不同的维度水平组合两个2d数组

我得到了2个2d数组，如下所示，我想将它们组合起来

     a       b      combine(a,b)   combine(b,a)
  1 1 1     3 3     1 1 1 3 3    3 3 1 1 1
  2 2 2     4 4     2 2 2 4 4    4 4 2 2 2
            5 5     0 0 0 5 5    5 5 0 0 0

我正在尝试下面的方法，但我对此感到困惑

import java.util.Arrays; 



class Main {

  public static int[] [] combine(int[][] a, int[][] b) {
    System.out.println(a[0].length+b[0].length);
        int[][] c = new int[a[0].length+b[0].length][b[1].length];

        for(int i = 0; i < a[0].length+b[0].length; i++) {
            for (int j = 0; j < b[1].length; j++) {
                System.out.println("a "+a[i][j]);
              if(i>a[0].length)
              {
                c[i][j]=b[i][j]
              }

             
                 
            }
        }
      return c;
    }
    
  

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

combine( a,  b);
/*
System.out.println(Arrays.deepToString(combine( a,  b))
                         .replace("],","\n").replace(",","\t| ")
                         .replaceAll("[\\[\\]]", " "));
                         */
  }
  
}

导入java.util.array；
班长{
公共静态int[][]combine（int[]a，int[]b）{
System.out.println（a[0].length+b[0].length）；
int[][]c=新的int[a[0]。长度+b[0]。长度][b[1]。长度]；
对于（int i=0；ia[0]。长度）
{
c[i][j]=b[i][j]
}
}
}
返回c；
}
公共静态void main（字符串[]args）{
int[][]a=新的int[][{{1,1,1}，{2,2,2}；
int[][]b=新的int[][{{3,3}，{4,4}，{5,5}；
联合收割机（a、b）；
/*
System.out.println（数组.deepToString（联合收割机（a，b））
.replace（“]，”，“\n”）。replace（“，”，“\t |”）
.replaceAll（“[\[\]]”，“”）；
*/
}
}

---

非常感谢您的帮助。谢谢您尝试分解问题：

首先计算出新数组的维度。假设两个输入数组都是矩形的（不是锯齿状的），组合数组的行数将与输入数组中行数较多的一个数组的行数相同，列数将与输入数组的列数之和相同。所以,

int[][] c = new int[Math.max(a.length, b.length)][a[0].length + b[0].length];

然后，第一个输入数组可以像正常情况一样填充到

c

：

for(int i = 0; i < a.length; i++) {
    for (int j = 0; j < a[0].length; j++) {
        c[i][j] = a[i][j];
    }
}

for（int i=0；i

第二个输入数组需要偏移几个位置。到底有多少地方？第一个输入数组中的列数：

for (int i = 0 ; i < b.length ; i++) {
    for (int j = 0 ; j < b[0].length ; j++) {
        c[i][j + a[0].length] = b[i][j];
//             ^^^^^^^^^^^^^
    }
}

for（int i=0；i

就这样

public static int[] [] combine(int[][] a, int[][] b) {
    System.out.println(a[0].length+b[0].length);
    int[][] c = new int[Math.max(a.length, b.length)][a[0].length + b[0].length];

    for(int i = 0; i < a.length; i++) {
        for (int j = 0; j < a[0].length; j++) {
            c[i][j] = a[i][j];
        }
    }
    for (int i = 0 ; i < b.length ; i++) {
        for (int j = 0 ; j < b[0].length ; j++) {
            c[i][j + a[0].length] = b[i][j];
        }
    }
    return c;
}

公共静态int[][]组合（int[][]a，int[]b）{
System.out.println（a[0].length+b[0].length）；
int[][]c=newint[Math.max（a.length，b.length）][a[0]。length+b[0]。length]；
for（int i=0；i

尝试分解问题：

首先计算出新数组的维度。假设两个输入数组都是矩形的（不是锯齿状的），组合数组的行数将与输入数组中行数较多的一个数组的行数相同，列数将与输入数组的列数之和相同。所以,

int[][] c = new int[Math.max(a.length, b.length)][a[0].length + b[0].length];

然后，第一个输入数组可以像正常情况一样填充到

c

：

for(int i = 0; i < a.length; i++) {
    for (int j = 0; j < a[0].length; j++) {
        c[i][j] = a[i][j];
    }
}

for（int i=0；i

第二个输入数组需要偏移几个位置。到底有多少地方？第一个输入数组中的列数：

for (int i = 0 ; i < b.length ; i++) {
    for (int j = 0 ; j < b[0].length ; j++) {
        c[i][j + a[0].length] = b[i][j];
//             ^^^^^^^^^^^^^
    }
}

for（int i=0；i

就这样

public static int[] [] combine(int[][] a, int[][] b) {
    System.out.println(a[0].length+b[0].length);
    int[][] c = new int[Math.max(a.length, b.length)][a[0].length + b[0].length];

    for(int i = 0; i < a.length; i++) {
        for (int j = 0; j < a[0].length; j++) {
            c[i][j] = a[i][j];
        }
    }
    for (int i = 0 ; i < b.length ; i++) {
        for (int j = 0 ; j < b[0].length ; j++) {
            c[i][j + a[0].length] = b[i][j];
        }
    }
    return c;
}

公共静态int[][]组合（int[][]a，int[]b）{
System.out.println（a[0].length+b[0].length）；
int[][]c=newint[Math.max（a.length，b.length）][a[0]。length+b[0]。length]；
for（int i=0；i

最好先计算结果数组的大小，然后分别用

a

和

b

中的值填充它：

公共静态int[][]组合（int[][]a，int[]b）{
int cols=a[0]。长度+b[0]。长度；
int rows=Math.max（a.length，b.length）；
System.out.println（“结果：行=“+rows+”，列=“+cols”）；
int[][]c=新的int[行][cols]；
for（int i=0；i

测试：

int[][]a=新的int[][{{1,1,1}，{2,2,2}；
int[][]b=新的int[][{{3,3}，{4,4}，{5,5}；
联合收割机（a、b）；
联合收割机（b，a）；

输出：

Result: rows=3, columns=5
[1, 1, 1, 3, 3]
[2, 2, 2, 4, 4]
[0, 0, 0, 5, 5]
Result: rows=3, columns=5
[3, 3, 1, 1, 1]
[4, 4, 2, 2, 2]
[5, 5, 0, 0, 0]

---

最好先计算结果数组的大小，然后分别用

a

和

b

中的值填充它：

公共静态int[][]组合（int[][]a，int[]b）{
int cols=a[0]。长度+b[0]。长度；
int rows=Math.max（a.length，b.length）；
System.out.println（“结果：行=“+rows+”，列=“+cols”）；
int[][]c=新的int[行][cols]；
for（int i=0；i

测试：

int[][]a=新的int[][{{1,1,1}，{2,2,2}；
int[][]b=新的int[][{{3,3}，{4,4}，{5，