¿Cómo encuentras la suma de todos los números en una matriz en Java?

Tengo un problema para encontrar la suma de todos los enteros en una matriz en Java. No puedo encontrar ningún método útil en la Mathclase para esto.

En java-8 puedes usar streams:

int[] a = {10,20,30,40,50};
int sum = IntStream.of(a).sum();
System.out.println("The sum is " + sum);

Salida:

La suma es 150.

Esta en el paquete java.util.stream

import java.util.stream.*;

Si está utilizando Java 8, la Arraysclase proporciona un stream(int[] array)método que devuelve una secuencia IntStreamcon la intmatriz especificada . También se ha sobrecargado para doubley longmatrices.

int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum(); //prints 10

También proporciona un método stream(int[] array, int startInclusive, int endExclusive)que le permite tomar un rango específico de la matriz (que puede ser útil):

int sum = Arrays.stream(new int []{1,2,3,4}, 0, 2).sum(); //prints 3

Finalmente, puede tomar una variedad de tipos T. Entonces, por ejemplo, puede tener un Stringque contiene números como entrada y si desea sumarlos simplemente haga lo siguiente:

int sum = Arrays.stream("1 2 3 4".split("\\s+")).mapToInt(Integer::parseInt).sum();

Esta es una de esas cosas simples que no existe (AFAIK) en la API estándar de Java. Es bastante fácil escribir el tuyo.

Otras respuestas están perfectamente bien, pero aquí hay una con un poco de azúcar sintáctica para cada uno.

int someArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;

for (int i : someArray)
    sum += i;

Además, incluso se muestra un ejemplo de suma de matrices en la Especificación del lenguaje Java 7 . El ejemplo es de la Sección 10.4 - Acceso a matrices .

class Gauss {
    public static void main(String[] args) {
        int[] ia = new int[101];
        for (int i = 0; i < ia.length; i++) ia[i] = i;
        int sum = 0;
        for (int e : ia) sum += e;
        System.out.println(sum);
    }
}

No puedes Otros lenguajes tienen algunos métodos para esto, como array_sum () en PHP, pero Java no.

Sólo..

int[] numbers = {1,2,3,4};
int sum = 0;
for( int i : numbers) {
    sum += i;
}

System.out.println(sum);

En Apache Math: hay StatUtils.sum(double[] arr)

El único punto que agregaría a las soluciones anteriores es que usaría un largo para acumular el total para evitar cualquier desbordamiento de valor.

int[] someArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE};
long sum = 0;

for (int i : someArray)
    sum += i;

int sum = 0;

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

En Java 8

Código :

   int[] array = new int[]{1,2,3,4,5};
   int sum = IntStream.of(array).reduce( 0,(a, b) -> a + b);
   System.out.println("The summation of array is " + sum);

  System.out.println("Another way to find summation :" + IntStream.of(array).sum());

Salida :

The summation of array is 15
Another way to find summation :15

Explicacion :

En Java 8, puede usar el concepto de reducción para hacer su adición.

Leer todo sobre Reducción

int sum = 0;
for (int i = 0; i < myArray.length; i++)
  sum += myArray[i];
}

En mi humilde opinión, una función de suma parece una buena opción para extender la clase Arrays donde viven, completan, ordenan, buscan, copian y equivalen. Hay muchos métodos útiles que se esconden en los javadocs, por lo que es una pregunta justa cuando se transfiere Fortran a Java para preguntar antes de lanzar nuestro propio método de ayuda. Busque en el enorme índice de javadoc "sum", "add" y cualquier otra palabra clave que se le ocurra. Probablemente sospeche que alguien ya ha hecho esto para tipos primitivos int, float, double, Integer, Float, Double No importa cuán simple, siempre es bueno verificarlo. Mantenga el código lo más simple posible y no reinvente la rueda.

Me gusta este método personalmente. Mi estilo de código es un poco raro.

public static int sumOf(int... integers) {
    int total = 0;
    for (int i = 0; i < integers.length; total += integers[i++]);
    return total;
}

Bastante fácil de usar en código:

int[] numbers = { 1, 2, 3, 4, 5 };
sumOf(1);
sumOf(1, 2, 3);
sumOf(numbers);

Yo uso esto:

public static long sum(int[] i_arr)
{
    long sum;
    int i;
    for(sum= 0, i= i_arr.length - 1; 0 <= i; sum+= i_arr[i--]);
    return sum;
}

Tienes que rodar el tuyo.
Empiezas con un total de 0. Luego, para cada número entero en la matriz, agrégalo a un total. Luego, cuando no tienes enteros, tienes la suma.

Si no hubiera enteros, entonces el total es 0.

Hay dos cosas que aprender de este ejercicio:

Debe iterar a través de los elementos de la matriz de alguna manera; puede hacerlo con un bucle for o un bucle while. Necesita almacenar el resultado de la suma en un acumulador. Para esto, necesita crear una variable.

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

Puede hacer que su código se vea mejor así:

public void someMethod(){
    List<Integer> numbers = new ArrayList<Integer>();
    numbers.addAll(db.findNumbers());
    ...
    System.out.println("Result is " + sumOfNumbers(numbers));
}

private int sumOfNumbers(List<Integer> numbers){
    int sum = 0;
    for (Integer i : numbers){
      sum += i;
    }
    return sum;
}

Depende. ¿Cuántos números estás agregando? Probar muchas de las sugerencias anteriores:

import java.text.NumberFormat;
import java.util.Arrays;
import java.util.Locale;

public class Main {

    public static final NumberFormat FORMAT = NumberFormat.getInstance(Locale.US);

    public static long sumParallel(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array).parallel().reduce(0,(a,b)->  a + b);
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumStream(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array).reduce(0,(a,b)->  a + b);
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumLoop(int[] array) {
        final long start = System.nanoTime();
        int sum = 0;
        for (int v: array) {
            sum += v;
        }
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumArray(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array) .sum();
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumStat(int[] array) {
        final long start = System.nanoTime();
        int sum = 0;
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }


    public static void test(int[] nums) {
        System.out.println("------");
        System.out.println(FORMAT.format(nums.length) + " numbers");
        long p = sumParallel(nums);
        System.out.println("parallel " + FORMAT.format(p));
        long s = sumStream(nums);
        System.out.println("stream " +  FORMAT.format(s));
        long ar = sumArray(nums);
        System.out.println("arrays " +  FORMAT.format(ar));
        long lp = sumLoop(nums);
        System.out.println("loop " +  FORMAT.format(lp));

    }

    public static void testNumbers(int howmany) {
        int[] nums = new int[howmany];
        for (int i =0; i < nums.length;i++) {
            nums[i] = (i + 1)%100;
        }
        test(nums);
    }

    public static void main(String[] args) {
        testNumbers(3);
        testNumbers(300);
        testNumbers(3000);
        testNumbers(30000);
        testNumbers(300000);
        testNumbers(3000000);
        testNumbers(30000000);
        testNumbers(300000000);
    }
}

Descubrí que, usando una máquina Ubuntu18 de 8 núcleos y 16 G, el ciclo era más rápido para valores más pequeños y el paralelo para valores más grandes. Pero, por supuesto, dependería del hardware que esté ejecutando:

------
3 numbers
6
parallel 4,575,234
6
stream 209,849
6
arrays 251,173
6
loop 576
------
300 numbers
14850
parallel 671,428
14850
stream 73,469
14850
arrays 71,207
14850
loop 4,958
------
3,000 numbers
148500
parallel 393,112
148500
stream 306,240
148500
arrays 335,795
148500
loop 47,804
------
30,000 numbers
1485000
parallel 794,223
1485000
stream 1,046,927
1485000
arrays 366,400
1485000
loop 459,456
------
300,000 numbers
14850000
parallel 4,715,590
14850000
stream 1,369,509
14850000
arrays 1,296,287
14850000
loop 1,327,592
------
3,000,000 numbers
148500000
parallel 3,996,803
148500000
stream 13,426,933
148500000
arrays 13,228,364
148500000
loop 1,137,424
------
30,000,000 numbers
1485000000
parallel 32,894,414
1485000000
stream 131,924,691
1485000000
arrays 131,689,921
1485000000
loop 9,607,527
------
300,000,000 numbers
1965098112
parallel 338,552,816
1965098112
stream 1,318,649,742
1965098112
arrays 1,308,043,340
1965098112
loop 98,986,436

Hay un método sum () en la biblioteca de subrayado-java .

Ejemplo de código:

import com.github.underscore.lodash.U;

public class Main {
    public static void main(String[] args) {
        int sum = U.sum(java.util.Arrays.asList(1, 2, 3, 4));

        System.out.println(sum);
        // -> 10
    }
}

Utilice la siguiente lógica:

static int sum()
     {
         int sum = 0; // initialize sum
         int i;

         // Iterate through all elements summing them up
         for (i = 0; i < arr.length; i++)
            sum +=  arr[i];

         return sum;
     }

No existe un 'método en una clase de matemáticas' para tal cosa. No es como si fuera una función de raíz cuadrada o algo así.

Solo necesita tener una variable para la suma y recorrer la matriz agregando cada valor que encuentre a la suma.

class Addition {

     public static void main() {
          int arr[]={5,10,15,20,25,30};         //Declaration and Initialization of an Array
          int sum=0;                            //To find the sum of array elements
          for(int i:arr) {
              sum += i;
          }
          System.out.println("The sum is :"+sum);//To display the sum 
     }
} 

Podemos usar la función definida por el usuario. Al principio, inicialice la variable suma igual a cero. Luego atraviese la matriz y agregue el elemento con suma. Luego actualice la variable suma.

Fragmento de código :

import java.util.*;   
import java.lang.*;  
import java.io.*;


class Sum
{
    public static int sum(int arr[])
    {
        int sum=0;

        for(int i=0; i<arr.length; i++)
        {
            sum += arr[i];
        }
        return sum;
    }

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

          int total = sum(arr);

          System.out.printf("%d", total);
    }
}

/**
 * Sum of all elements from 1 to 1000
 */
final int sum = Stream.iterate(1, n -> n + 1).limit(1000).mapToInt(el -> el).sum();

Un poco sorprendido de ver Ninguna de las respuestas anteriores considera que puede ser varias veces más rápido usando un grupo de subprocesos. Aquí, parallelutiliza un grupo de subprocesos de unión de horquilla y divide automáticamente la secuencia en varias partes y las ejecuta en paralelo y luego se fusiona. Si solo recuerda la siguiente línea de código, puede usarla en muchos lugares.

Entonces, el premio al código corto y dulce más rápido es para -

int[] nums = {1,2,3};
int sum =  Arrays.stream(nums).parallel().reduce(0, (a,b)-> a+b);

Digamos que quieres hacer sum of squares, luego Arrays.stream (nums) .parallel (). Map (x-> x * x) .reduce (0, (a, b) -> a + b). La idea es que todavía puede realizar una reducción, sin mapa.

 public class Num1
 {
     public static void main ()
     {
          //Declaration and Initialization
          int a[]={10,20,30,40,50}

          //To find the sum of array elements
          int sum=0;
          for(int i=0;i<a.length;i++)
          {
              sum=sum+i;
          }

          //To display the sum
          System.out.println("The sum is :"+sum);

     }
  } 

public class AddDemo {

    public static void main(String[] args) {

        ArrayList <Integer>A = new ArrayList<Integer>();

        Scanner S = new Scanner(System.in);

        System.out.println("Enter the Numbers: ");

        for(int i=0; i<5; i++){

            A.add(S.nextInt());
        }

        System.out.println("You have entered: "+A);

        int Sum = 0;

        for(int i=0; i<A.size(); i++){

            Sum = Sum + A.get(i);

        }

        System.out.println("The Sum of Entered List is: "+Sum);

    }

}

A partir de Java 8 El uso de expresiones lambda se ha vuelto disponible.

Mira esto:

int[] nums = /** Your Array **/;

Compacto:

int sum = 0;
Arrays.asList(nums).stream().forEach(each -> {
    sum += each;
});

Preferir:

int sum = 0;

ArrayList<Integer> list = new ArrayList<Integer>();

for (int each : nums) { //refer back to original array
     list.add(each); //there are faster operations…
}

list.stream().forEach(each -> {
    sum += each;
});

Devolución o impresión de suma.