如何求和两个二维数组的元素

Question

我正在尝试使用java流API将两个二维数组的元素添加到一起
我用一维数组解决了这个问题，但我不知道如何进一步处理二维数组。

以下是要转换的代码：

public static int[][] add(final int[][] m1, final int[][] m2) {
    int[][] e = new int[m2.length][m2[0].length];
    for (int i = 0; i < m1.length; i++) {
        for (int j = 0; j < m1[i].length; j++) {
            e[i][j] = m1[i][j] + m2[i][j];
        }
    }
    return e;
}

这是我为同样的目的编写的代码，但只使用一维数组：

public static int[] addOneDimension(final int[] a, final int b[]) {
    int[] c = IntStream.range(0, a.length)
            .map(i -> a[i] + b[i])
            .toArray();
    return c;
}

特别是，我不知道如何在二维数组上使用map()方法。

Answer 1

这可以使用IntStream及其方法mapToObj处理行，map处理每行中的元素来实现：

static int[][] add(int[][] a, int [][] b) {
    return IntStream.range(0, a.length)
                    .mapToObj(i -> add(a[i], b[i])) // int[] is object
                    .toArray(int[][]::new);         // create new 2D array
}
    
static int[] add(int[] a, int[] b) {
    return IntStream.range(0, a.length)
                    .map(i -> a[i] + b[i])  // processing int operands
                    .toArray();             // IntStream.toArray() returns int[]
}

测试

int[][] a = {
    {1, 2},
    {3, 4}
};
int[][] b = {
    {10, 20},
    {30, 40}
};
System.out.println("Sum of a + b = ");
Arrays.stream(add(a, b))
      .map(Arrays::toString)
      .forEach(System.out::println);

输出

Sum of a + b = 
[11, 22]
[33, 44]

---

单一方法的实现可能如下：

static int[][] add2D(int[][] a, int [][] b) {
    return IntStream
            .range(0, a.length)
            .mapToObj(i -> IntStream
                            .range(0, a[i].length)
                            .map(j -> a[i][j] + b[i][j])
                            .toArray()
            )
            .toArray(int[][]::new);
}

Answer 2

您可以使用Stream#reduce方法对两个或多个2d数组的元素求和：

public static int[][] sumArrays(int[][]... arrays) {
    // reduce the stream of arrays into a single
    // array by sequentially summing array pairs
    return Arrays.stream(arrays).reduce((a1, a2) -> IntStream
            // iterate over the indices of
            // the rows of the largest array
            .range(0, Math.max(a1.length, a2.length))
            .mapToObj(i -> IntStream
                    // iterate over the indices of
                    // the cells of the largest row
                    .range(0, Math.max(
                            i < a1.length ? a1[i].length : 0,
                            i < a2.length ? a2[i].length : 0))
                    // sum the elements of two rows if exist, or 0 otherwise
                    .map(j -> (i < a1.length && j < a1[i].length ? a1[i][j] : 0)
                            + (i < a2.length && j < a2[i].length ? a2[i][j] : 0))
                    .toArray())
            .toArray(int[][]::new))
            .orElse(null);
}

// test
public static void main(String[] args) {
    int[][] arr1 = {
            {1},
            {1, 1}};
    int[][] arr2 = {
            {2},
            {2, 2},
            {2, 2, 2}};
    int[][] arr3 = {
            {3, 3, 3, 3},
            {3, 3, 3, 3},
            {3, 3, 3, 3},
            {3, 3, 3, 3}};
    int[][] sum = sumArrays(arr1, arr2, arr3);
    // output
    Arrays.stream(sum).map(Arrays::toString).forEach(System.out::println);
    //[6, 3, 3, 3]
    //[6, 6, 3, 3]
    //[5, 5, 5, 3]
    //[3, 3, 3, 3]
}

---

^{另请参阅：2个不同2d阵列的总和}