Como você encontra a soma de todos os números em uma matriz em Java?

Estou tendo um problema para encontrar a soma de todos os números inteiros em uma matriz em Java. Não consigo encontrar nenhum método útil na Mathclasse para isso.

No java-8 você pode usar fluxos:

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

Resultado:

A soma é 150.

Está no pacote java.util.stream

import java.util.stream.*;

Se você estiver usando o Java 8, a Arraysclasse fornece um stream(int[] array)método que retorna um seqüencial IntStreamcom a intmatriz especificada . Também foi sobrecarregado por doublee longmatrizes.

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

Ele também fornece um método stream(int[] array, int startInclusive, int endExclusive)que permite que você pegue um intervalo especificado da matriz (que pode ser útil):

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

Finalmente, pode levar uma matriz do tipo T. Assim, por exemplo, você pode ter um Stringque contém números como entrada e, se quiser somar, basta:

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

Essa é uma daquelas coisas simples que não existem (AFAIK) na API Java padrão. É fácil escrever o seu próprio.

Outras respostas são perfeitamente boas, mas aqui está uma com um pouco de açúcar sintático para cada um.

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

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

Além disso, um exemplo de soma de matriz é mostrado na especificação da linguagem Java 7 . O exemplo é da Seção 10.4 - Acesso à matriz .

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);
    }
}

Você não pode. Outras linguagens têm alguns métodos para isso, como array_sum () no PHP, mas Java não.

Somente..

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

System.out.println(sum);

No Apache Math: existe StatUtils.sum(double[] arr)

O único ponto que eu acrescentaria às soluções anteriores é que usaria um longo para acumular o total para evitar qualquer excesso 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];
}

No 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());

Saída :

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

Explicação :

Em Java 8, você pode usar o conceito de redução para fazer sua adição.

Leia tudo sobre redução

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

IMHO uma função soma pareceria um bom ajuste para estender a classe Arrays, onde preencher, classificar, pesquisar, copiar e igual a viver. Existem muitos métodos úteis ocultos nos javadocs, portanto, é uma boa pergunta ao enviar o Fortran ao java para perguntar antes de lançar nosso próprio método auxiliar. Pesquise no enorme índice javadoc por "sum", "add" e qualquer outra palavra-chave em que você possa imaginar. Você pode suspeitar que alguém já tenha feito isso para os tipos primitivos int, float, double, Inteiro, Float, Double? Não importa quão simples, é sempre bom verificar. Mantenha o código o mais simples possível e não reinvente a roda.

Eu gosto desse método pessoalmente. Meu estilo de código é um pouco estranho.

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

Muito fácil de usar no código:

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

Eu uso isso:

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;
}

Você tem que rolar o seu próprio.
Você começa com um total de 0. Em seguida, considera todos os números inteiros da matriz e o adiciona a um total. Então, quando você estiver sem números inteiros, terá a soma.

Se não houvesse números inteiros, o total é 0.

Há duas coisas a aprender com este exercício:

Você precisa percorrer os elementos da matriz de alguma maneira - você pode fazer isso com um loop for ou um while. Você precisa armazenar o resultado da soma em um acumulador. Para isso, você precisa criar uma variável.

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

Você pode fazer com que seu código fique melhor assim:

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. Quantos números você está adicionando? Testando muitas das sugestões acima:

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);
    }
}

Descobri que, usando uma máquina Ubuntu18 de 8 núcleos e 16 G, o loop era mais rápido para valores menores e o paralelo para maiores. Mas é claro que isso dependeria do hardware que você está executando:

------
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

Existe um método sum () na biblioteca underscore-java .

Exemplo 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
    }
}

Use abaixo da 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;
     }

Não existe um "método em uma aula de matemática" para isso. Não é como uma função de raiz quadrada ou algo parecido.

Você só precisa ter uma variável para a soma e fazer um loop pela matriz, adicionando cada valor encontrado à soma.

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 a função definida pelo usuário. Inicialmente, inicialize a variável soma igual a zero. Em seguida, percorra a matriz e adicione o elemento com soma. Atualize a variável sum.

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();

Um pouco surpreso ao ver Nenhuma das respostas acima considera que pode ser várias vezes mais rápido usando um pool de threads. Aqui,parallel usa um conjunto de encadeamentos de junção de bifurcação e interrompe automaticamente o fluxo em várias partes e as executa paralelamente e depois mescladas. Se você se lembrar da seguinte linha de código, poderá usá-la em vários lugares.

Portanto, o prêmio pelo código curto e doce mais rápido vai para -

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

Digamos que você queira fazer sum of squares, e Arrays.stream (nums) .parallel (). Map (x-> x * x) .reduce (0, (a, b) -> a + b). A idéia é que você ainda pode executar reduzir, sem 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 do Java 8, o uso de expressões lambda tornou-se disponível.

Veja isso:

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

Compactar:

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;
});

Retornar ou imprimir soma.