将两个二维 Arrays 变成一个二维数组，不同长度的 Arrays 和不同长度的 Arrays inside 2D Array

Question

你好，

我怎样才能将两个 2D Arrays变成一个 2D Array 。 Array 长度与 Other不同。 在二维数组中， Arrays也可以有不同的长度。

例子：

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

结果应该是

addedUpAry2D == {{1,1,1,1},{2,2,2},{3,3,3},{4},{5,5,5,5,5}}

我不能用二维阵列喷射它，只能用一维阵列（如下所示）谢谢

import java.util.Arrays;

public class ArraysAndMore {

    public static int[] add2D(int[][]ary1, int[][]ary2){
    //Attention please. the return must be a two dimensional Array, because i couldnt do it, i did it with a one Dimensional Array.

        int aryElementCountFirst = 0;
        int aryElementCountSecond = 0;

        for (int[] i:ary1) {
            for (int n:i) {
                aryElementCountFirst++;
            }
        }

        for (int[] i:ary2) {
            for (int n:i) {
                aryElementCountSecond++;
            }
        }

        int[]arysInOneDFirst = new int[aryElementCountFirst];
        int[]arysInOneDSecond = new int[aryElementCountSecond];
        int counter = 0;

        for (int[] i:ary1) {
            for (int n:i) {
                arysInOneDFirst[counter++] = n;
            }
        }

        int counter2 = 0;
        for (int[] i:ary2) {
            for (int n:i) {
                arysInOneDSecond[counter2++] = n;
            }
        }

        int[] aryTwo1Dtogether = add(arysInOneDFirst, arysInOneDSecond);
        return aryTwo1Dtogether; **//should be a 2D Array!!**
    }

    public static int[] add(int[] ary1, int[]ary2) {

        ** //This Method turns two 1D Arrays into one 1D Array**\

        if(ary1.length==0 && ary2.length==0){
            return new int[0];
        }
        int[]addedUp = new int[ary1.length+ ary2.length];
        int counter = 0;
        for (int i = 0; i < ary1.length; i++) {
            addedUp[counter++] = ary1[i];
        }
        for (int i = 0; i < ary2.length; i++) {
            addedUp[counter++] = ary2[i];
        }
        return addedUp;
    }
    
    public static void main(String[] args) {

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

        System.out.println(Arrays.toString(add2D(ary2D1, ary2D2)));
    }
    
}

我的 Output 看起来像这样：

[1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 5, 5, 5, 5, 5]

它需要看起来像这样：

{{1,1,1,1},{2,2,2},{3,3,3},{4},{5,5,5,5,5}}

Answer 1

像这样尝试。

• 使用Arrays.copyOf创建一个相同大小的新数组并复制第一个。
• 那么最简单的方法就是使用循环将第二个数组复制到第一个数组。
• 这确保了结果数组不与前两个共享对象。

public class ArraysAndMore {

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

        int[][] result = add2D(ary2DFirst, ary2DSecond);
        System.out.println(Arrays.deepToString(result));
    }

   public static int[][] add2D(int[][] ary1, int[][] ary2) {
        // allocate a new array of proper size
        int[][] result = new int[ary1.length + ary2.length][];
        
        // copy the first array
        for (int i = 0; i < ary1.length; i++) {
            result[i] = Arrays.copyOf(ary1[i], ary1[i].length);
        }
        
        // copy the second array;
        int k = ary1.length;
        for (int i = 0; i < ary2.length; i++) {
            result[k++] = Arrays.copyOf(ary2[i], ary2[i].length);
        }
        return result;
    }
}

印刷

[[1, 1, 1, 1], [2, 2, 2], [3, 3, 3], [4], [5, 5, 5, 5, 5]]

要记住的关键是二维 arrays 只是 arrays 的 arrays。

完成同样事情的另一种方法是使用流。

int result2[][] = Stream.of(ary2DFirst, ary2DSecond)
                .flatMap(Arrays::stream).map(s -> Arrays.copyOf(s, s.length))
                .toArray(int[][]::new);

需要Arrays.copyOf以确保 arrays 不共享对象。

Answer 2

您可以使用System.arraycopy来执行此操作。 您不需要指定数组第二维的大小（这是您能够以原始 arrays 开始的方式）。

第一个副本获取a1并将其添加到a （生成的数组），然后将a2添加到a1的末尾（现在位于a中）。

public class so75024045 {
    public static void main(String[] args) {
        int[][] a1 = new int[][] { { 1, 1, 1, 1 }, { 2, 2, 2 }, { 3, 3, 3 } };
        int[][] a2 = new int[][] { { 4 }, { 5, 5, 5, 5, 5 } };
        int[][] a = new int[a1.length + a2.length][];

        System.arraycopy(a1, 0, a, 0, a1.length);
        System.arraycopy(a2, 0, a, a1.length, a2.length);

        for (int[] x : a) {
            for (int y : x) {
                System.out.print(y + " ");
            }
            System.out.println("");
        }
    }
}

Answer 3

使用流的另一种简单方法：

public static int[][] add2D(int[][]ary1, int[][]ary2){
    return Stream.concat(Arrays.stream(ary1), Arrays.stream(ary2))
                 .toArray(int[][]::new);
}