• lambda总是短解的好选择 *

int mat[][] = { {43, 2, 21}, {1, 2, 4, 54}, {5, 84, 2}, {11, 5, 3, 1}};    

int[] array = Arrays.stream(mat)
    .reduce((a1, a2) -> IntStream.range(0, Math.max(a1.length, a2.length))
        .map(i -> i < a1.length && i < a2.length ? a1[i] + a2[i]
            : i < a1.length ? a1[i] : a2[i] ).toArray()).get();

• （可处理不同长度的行）*

你可以用下面的代码-

const arr = [[43, 2, 21],[1, 2, 4, 54],[5, 84, 2],[11, 5, 3, 1]];
const sumArray = (array) => {
   const newArray = [];
   array.forEach(sub => {
      sub.forEach((num, index) => {
         if(newArray[index]){
            newArray[index] += num;
         }else{
            newArray[index] = num;
         }
      });
   });
   return newArray;
}

public static void main(String args[]) {

        int numbers[][] = {{43, 2, 21},{1, 2, 4, 54},{5, 84, 2},{11, 5, 3, 1}};
        int result[]=new int[4];
        
        for(int a=0;a<4;a++) {
            for(int b=0;b<4;b++) {
                try {
                result[b]+=numbers[a][b];
                }catch(IndexOutOfBoundsException e) {
                    
                }
            }
        }
        
        System.out.println(Arrays.toString(result));
        
    }

这个解决方案可以很好的工作，只是它需要O（n^2）来完成。我们可以记录一些错误消息，当数组元素大小不一样的时候。

public static void main (String[] args) {
        int[][] input = {{43, 2, 21},{1, 2, 4, 54},{5, 84, 2},{11, 5, 3, 1}};
        int[] output = new int[input.length];

        for (int i = 0; i < input.length ; i++) {
            for (int j = 0; j < input.length; j++) {
                try {
                    output[j] = output[j] + input[i][j];
                }catch (ArrayIndexOutOfBoundsException e) {
                    System.out.println("Size is not same");
                }
            }
        }
        System.out.println(Arrays.toString(output));
    }

如果你知道“两个指针算法”，你可以在O（n）时间复杂度内解决这个问题。

public static void main(String[] args) {
    int[][] num = {{43, 2, 21, 100},{1, 2, 4, 54},{5,84,2,1,1},{11,5,3,1}};

    int size = 0;

    int i = 0;
    int j = 0;
    int sum = 0;
    while(true){
        if(i == num.length){
            /**
             * insert sum into result array here
             */

            if(i == num.length && j == num[i-1].length)
                break;

            sum = 0;
            i = 0;
            j++;
        }

        if(j < num[i].length) {
            sum += num[i][j];
        }
        i++;
    }
}

/如果你确实希望看到添加的所有值（比如numeric）都包含在某个数组中，那么可以这样做（基于JS语言）：
假设我们将一系列发票存储到一个数组中（这里称为'invoiceValues'）：/

const invoiceValues = [46, 7, 22, 247, 24601, 9430];

/假设我们希望从"invoiceValues"数组包含的每张发票中推导出增值税和相关的应税值：/

const onlyVatValues = [];
const onlyTaxableValues = [];

/说，并创建了2个空数组，我创建了一个简单的函数（表达式）'calcVat'，以计算增值税，这里只是设置为20%作为一个简单的例子：/

const calcVat = function (invoiceTotal) {
    return invoiceTotal * 0.20; 
}

/现在，我们将对'invoiceValues'数组的所有元素执行'for'语句（https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for）;然后，我们将通过'push（）'方法（https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push）用所需的数据填充两个空数组，因此，我将数组调用到控制台。/

for (let i = 0; i < invoiceValues.length; i++) {
    const deducedVats = calcVat(invoiceValues[i]);
    onlyVatValues.push(deducedVats);
    onlyTaxableValues.push(invoiceValues[i] - deducedVats);
}
console.log(onlyTaxableValues, onlyVatValues, invoiceValues);

/最后是变量'valuesSUM'中的函数，它回答了关于对数组值求和的问题：/

const valuesSum = function(arr) {
    let sum = 0;
    for (let i = 0; i < arr.length; i++) {
            // sum = sum + arr[i]; // or either you can use: 
        sum += arr[i]; 
    }
    return sum;
}

console.log(valuesSum(invoiceValues));
console.log(valuesSum(onlyVatValues));
console.log(valuesSum(onlyTaxableValues));

好好享受吧!