Comment trouvez-vous la somme de tous les nombres dans un tableau en Java?

Dans java-8, vous pouvez utiliser les flux:

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

Sortie:

La somme est de 150.

C'est dans le paquet java.util.stream

import java.util.stream.*;

C'est l'une de ces choses simples qui n'existent pas (AFAIK) dans l'API Java standard. Il est assez facile d'écrire votre propre.

D'autres réponses sont parfaitement correctes, mais en voici une avec un peu de sucre syntaxique pour chaque.

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

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

De plus, un exemple de sommation de tableau est pair montré dans la spécification du langage Java 7. L'exemple est à partir de Section 10.4 - Accès au Tableau.

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

Si vous utilisez Java 8, le Arrays la classe fournit un stream(int[] array) méthode qui renvoie une séquentiel IntStream avec l' int tableau. Il a également été surchargé pour les tableaux double et long.

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

, Il fournit également une méthode stream(int[] array, int startInclusive, int endExclusive) ce qui vous permet de prendre une plage spécifiée du tableau (ce qui peut être utile):

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

Enfin, il peut prendre un tableau de type T. Vous pouvez donc par exemple avoir un String qui contient les nombres en entrée et si vous voulez les additionner, faites simplement:

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

Vous ne pouvez pas. D'autres langages ont des méthodes pour cela comme array_sum () en PHP, mais Java ne le fait pas.

Juste..

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

System.out.println(sum);

Le seul point que j'ajouterais aux solutions précédentes est que j'utiliserais un long pour accumuler le total pour éviter tout débordement de valeur.

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

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

Dans Apache Math: Il y a StatUtils.sum(double[] arr)

Dans Java 8

Code:

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

Sortie:

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

Explication:

Dans Java 8, vous pouvez utiliser le concept de réduction pour faire votre addition.

Tout savoir sur la réduction

int sum = 0;

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

À mon humble avis, une fonction sum semblerait un bon ajustement pour étendre la classe Arrays où fill, sort, search, copy, & equals live. Il y a beaucoup de méthodes pratiques qui se cachent dans les javadocs, c'est donc une bonne question lors du portage de Fortran vers java de demander avant de lancer notre propre méthode d'aide. Recherchez dans l'énorme index javadoc "sum", "add" et tout autre mot-clé auquel vous pourriez penser. Vous pourriez soupçonner que quelqu'un l'a déjà fait pour les types primitifs int, float, double, Integer, Float, Double? Peu importe la simplicité, il est toujours bon de vérifier. Gardez le code aussi simple que possible et ne réinventez pas la roue.

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

J'aime personnellement cette méthode. Mon style de code est un peu bizarre.

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

Assez facile à utiliser dans le code:

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

Vous devez rouler votre propre.
Vous commencez avec un total de 0. Ensuite, vous considérez pour chaque entier du tableau, ajoutez - le à un total. Ensuite, lorsque vous n'avez plus d'entiers, vous avez la somme.

S'il n'y avait pas d'entiers, alors le total est 0.

Il y a deux choses à apprendre de cet exercice :

Vous devez parcourir les éléments du tableau d'une manière ou d'une autre - vous pouvez le faire avec une boucle for ou une boucle while. Vous devez stocker le résultat de la somme dans un accumulateur. Pour cela, vous devez créer une variable.

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

Vous pouvez rendre votre code meilleur comme ceci:

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

define a sum variable = 0

for each number in array:
    sum = sum + number

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

     }
  } 

Nous pouvons utiliser la fonction définie par l'utilisateur. Initialisez d'abord la variable somme égale à zéro. Parcourez ensuite le tableau et ajoutez un élément avec sum . Mettez ensuite à jour la variable sum.

Extrait de code:

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

J'utilise ceci:

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

Il existe une méthode sum() dans la bibliothèque underscore-java.

Exemple de code:

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

Il n'existe pas de méthode dans une classe de mathématiques " pour une telle chose. Ses pas comme sa fonction racine carrée ou quelque chose comme ça.

Il vous suffit d'avoir une variable pour la somme et de parcourir le tableau en ajoutant chaque valeur que vous trouvez à la somme.

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

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

    }

}

À partir de Java 8, l'utilisation d'expressions lambda est devenue disponible.

Voir ceci:

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

Compact:

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

Préférez:

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

Retourner ou imprimer la somme.

Utiliser la logique ci-dessous

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

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

         return sum;
     }