Obtener la suma de un array en Java

Para sumar un int[] en Java, usa Arrays.stream(numbers).sum() como opción integrada y concisa, o suma cada valor con un bucle for si quieres controlar el proceso explícitamente. Los arrays de Java no tienen un método de instancia sum(); Arrays.stream(int[]) convierte sus valores en un IntStream, que ofrece sum() y reduce().
Sumar un array es una de las operaciones básicas con datos del Tutorial de Java, que ordena las guías de arrays y colecciones desde lo básico hasta los streams.

Los ejemplos siguientes usan los mismos seis valores, cuya suma aritmética es 149. Cada programa es independiente y se puede guardar como SimpleTesting.java.

Sumar un array de int con un bucle for

Un bucle normal permite ver cada paso: inicializar el acumulador, recorrer cada índice y sumar el elemento correspondiente. Es una opción sencilla si quieres seguir el cálculo o añadir otra lógica durante el recorrido.

Este programa suma los seis valores de numbers e imprime el total. La condición del bucle usa numbers.length, y el nombre del array se mantiene igual tanto para consultar su longitud como para acceder a sus elementos.

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = 0;

    for (int i = 0; i < numbers.length; i++) {
      total += numbers[i];
    }

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sumar un array de int con un flujo paralelo y reduce

Llama a parallel() sobre el IntStream que devuelve Arrays.stream(numbers) para usar un flujo paralelo. El método reduce de dos argumentos recibe un valor de identidad (0) y una operación de suma. Como la suma es asociativa, se pueden combinar subtotales para obtener el mismo resultado. Para un array pequeño, prefiere la versión secuencial, salvo que el procesamiento paralelo encaje con la carga de trabajo general; ejecutarlo en paralelo no hace que un cálculo pequeño sea más rápido automáticamente.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = Arrays.stream(numbers)
        .parallel()
        .reduce(0, (left, right) -> left + right);

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sumar un array de int con Arrays.stream(...).reduce(...)

En un flujo secuencial, omite parallel(). Arrays.stream(int[]) sigue devolviendo un IntStream; reduce(0, Integer::sum) comienza con el valor de identidad y combina cada valor primitivo mediante la suma. El valor de identidad define la operación incluso cuando no hay valores que combinar.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = Arrays.stream(numbers).reduce(0, Integer::sum);

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sumar un array de int con Arrays.stream(...).sum()

Cuando la operación es una suma, sum() expresa la intención de forma más directa que una reducción. Es una operación terminal del IntStream creado a partir del array y devuelve un total de tipo int.

Como este método devuelve int, el total usa la aritmética de enteros de 32 bits de Java. Si la suma matemática puede superar el rango de int, convierte el flujo a un tipo más amplio antes de sumar, por ejemplo con Arrays.stream(numbers).asLongStream().sum(). Para manejar ese rango, el bucle normal también necesita un acumulador long y convertir cada valor a un tipo más amplio.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = Arrays.stream(numbers).sum();

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sumar un array de int con IntStream.of(...).sum()

IntStream.of(numbers) es otra forma directa de crear un IntStream a partir de un int[]. Su operación sum() devuelve el mismo total que Arrays.stream(numbers).sum(). Elige la forma que se lea mejor en tu código.

import java.util.stream.IntStream;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = IntStream.of(numbers).sum();

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Sumar un array de int con un bucle for compacto

El bucle siguiente reúne la inicialización, la condición de continuación y la acumulación en la cabecera de for; después, recorre el array desde el último índice hasta el primero. Es Java válido, pero el cuerpo vacío y el decremento dentro de la expresión de actualización hacen que cueste más leerlo que el bucle normal. Usa la forma más clara, salvo que la versión compacta te resulte especialmente útil.

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total;
    int i;

    for (total = 0, i = numbers.length - 1;
         i >= 0;
         total += numbers[i--]) {
      // Accumulation happens in the loop update expression.
    }

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149