Comment trouver 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 du sucre syntaxique pour chaque réponse.

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

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

aussi, un exemple de sommation de tableau est même indiqué dans la spécification de langage Java 7 . L'exemple est tiré de à la 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, la classe Arrays fournit une méthode stream(int[] array) qui retourne une méthode séquentielle IntStream avec le tableau spécifié int . Il a également été surchargé pour les réseaux 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) qui vous permet de prendre une gamme spécifiée de la tableau (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 . Ainsi, vous pouvez par exemple avoir un String qui contient des nombres comme entrée et si vous voulez les additionner faites juste:

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

vous ne pouvez pas. D'autres langues ont des méthodes pour cela comme array_sum() en PHP, mais pas Java.

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;

en mathématiques Apache : 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 ajout.

tout savoir sur la réduction

int sum = 0;

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

IMHO une fonction de somme semblerait un bon ajustement pour étendre la classe des tableaux où remplir, trier, rechercher, copier, & égale en direct. Il y a beaucoup de méthodes pratiques cachées dans les javadocs, donc c'est une bonne question lors du portage de Fortran vers java à poser avant de lancer notre propre méthode helper. Recherchez dans l'énorme index javadoc "sum", " add " et tout autre mot-clé auquel vous pourriez penser. Vous pouvez soupçonner certainement quelqu'un a déjà fait cela pour les types primitifs int, float, double, entier, Float, En Double? N'importe comment simple, 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 cette méthode personnellement. 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 le vôtre.

Vous commencez avec un total de 0. Puis vous considérez pour chaque entier dans le tableau, ajoutez-le à un total. Quand 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 itérer à travers 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 sommation 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 améliorer l'apparence de votre code:

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. D'abord initialiser la variable de somme égale à zéro. Puis parcourez le tableau et ajoutez l'élément avec la somme . Puis mettre à 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 y a 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'y a 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.

vous avez juste besoin d'avoir une variable pour la somme et boucle à travers le tableau 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);

    }

}

depuis Java 8, l'utilisation des expressions lambda est 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;
});

retour ou imprimer la somme.

Utiliser le soufflet de la logique

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