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

141

J'ai un problème pour trouver la somme de tous les nombres entiers dans un tableau en Java. Je ne trouve aucune méthode utile dans la Mathclasse pour cela.

TomLisankie
la source
15
Écrivez le vôtre, le code pour le faire fait 2-3 lignes.
wkl
2
Malheureusement, les "réponses" ci-dessus (et suivantes) sont "The Java Way": - / Vous pouvez utiliser la bibliothèque Functional Java , mais il est si compliqué de gérer la syntaxe Java.
1
Je sais que cette question est extrêmement ancienne, mais la réponse de msayag ci-dessous semble devoir être marquée comme réponse acceptée.
Matsu Q.
Le problème avec l'écriture que vous possédez est que c'est une boucle. Lorsque vous prenez une somme de 3 nombres, vous devriez pouvoir le faire en une seule instruction.
Al G Johnston

Réponses:

269

Dans vous pouvez utiliser des flux:

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

Production:

La somme est de 150.

C'est dans le paquet java.util.stream

import java.util.stream.*;
msayag
la source
1
Que faire si le tableau contient de grands nombres et que la somme est hors de portée int?
thanhbinh84
5
Dans ce cas, vous pouvez utiliser LongStream, soit comme long sum = IntStream.of (a) .asLongStream (). Sum (); ou longue somme = LongStream.of (a) .sum ();
msayag
2
Y a-t-il un avantage de vitesse considérable à utiliser les flux?
mvorisek le
1
Si votre somme ne tient pas longtemps, vous devez faire la somme par paire (diviser et conquérir), car la somme de BigDecimals plus petits est plus rapide.
user482745
1
@HosseinRahimijava.util.stream.DoubleStream.of(a).sum();
ggorlen
48

Si vous utilisez Java 8, la Arraysclasse fournit une stream(int[] array)méthode qui renvoie un séquentiel IntStreamavec le inttableau spécifié . Il a également été surchargé pour les tableaux doubleet 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 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. Ainsi, vous pouvez par exemple avoir un Stringqui contient des 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();
Alexis C.
la source
35

C'est l'une de ces choses simples qui n'existent pas (AFAIK) dans l'API Java standard. C'est assez facile d'écrire le vôtre.

D'autres réponses sont parfaitement bien, mais en voici une avec du 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;

En outre, un exemple de sommation de tableau est même présenté dans la spécification du langage Java 7 . L'exemple est tiré de la Section 10.4 - Accès aux tableaux .

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);
    }
}
wkl
la source
Mais cela n'ajoute pas tous les chiffres d'un seul coup. C'est inefficace.
Al G Johnston
20

Vous ne pouvez pas. D'autres langages 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);
user434665
la source
6
Tu me manques .NET Sum (IEnumerable <Int32>) msdn.microsoft.com/en-us/library/…
Akira Yamamoto
15

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

fodon
la source
Pourquoi seulement dans les statuts: D
Lore
13

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;
Peter Lawrey
la source
6
int sum = 0;

for (int i = 0; i < yourArray.length; i++)
{
  sum = sum + yourArray[i];
}
Bnjmn
la source
4
Vous pouvez le rendre encore plus agréable avec une boucle for-each (introduite dans Java 1.5).
wkl
6

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

Kick Buttowski
la source
4
int sum = 0;
for (int i = 0; i < myArray.length; i++)
  sum += myArray[i];
}

la source
4

À mon humble avis, une fonction de somme semblerait un bon choix pour étendre la classe Arrays où le remplissage, le tri, la recherche, la copie et l'égalité vivent. Il y a beaucoup de méthodes pratiques cachées 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 penser que quelqu'un a déjà fait cela pour les types primitifs int, float, double, Integer, Float, Double? Aussi simple soit-il, il est toujours bon de vérifier. Gardez le code aussi simple que possible et ne réinventez pas la roue.

Darrell
la source
3

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);
Sons authentiques
la source
3

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;
}
jsanmarb
la source
1
C-programmeur, hein?
towi
2

Vous devez rouler le vôtre.
Vous commencez avec un total de 0. Ensuite, vous considérez pour chaque entier du tableau, ajoutez-le à un total. Ensuite, lorsque vous êtes à court d'entiers, vous avez la somme.

S'il n'y avait pas d'entiers, le total est égal à 0.

chustar
la source
2

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 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];
}
Amir Afghani
la source
2

Vous pouvez améliorer l'apparence de votre code 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;
}
Gondim
la source
2

Ça dépend. Combien de nombres ajoutez-vous? Tester plusieurs des suggestions ci-dessus:

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

J'ai trouvé, en utilisant une machine Ubuntu18 à 8 cœurs et 16 G, la boucle était la plus rapide pour les petites valeurs et le parallèle pour les plus grandes. Mais bien sûr, cela dépendra du matériel que vous utilisez:

------
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
Gérardw
la source
1

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
    }
}
Valentyn Kolesnikov
la source
1

Utilisez la logique ci-dessous:

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;
     }
Vipul Gulhane
la source
0

Il n'y a pas de «méthode dans une classe de mathématiques» pour une telle chose. Ce n'est pas comme si c'était une 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 trouvée à la somme.

jbx
la source
0
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 
     }
} 
Ashok Vunnam
la source
Copie de la réponse existante.
james.garriss
0

Nous pouvons utiliser une fonction définie par l'utilisateur. Initialisez d'abord la variable de somme égale à zéro. Ensuite, parcourez le tableau et ajoutez l'élément avec la somme. Mettez ensuite à jour la variable de somme.

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);
    }
}
éruptions cutanées
la source
0
/**
 * Sum of all elements from 1 to 1000
 */
final int sum = Stream.iterate(1, n -> n + 1).limit(1000).mapToInt(el -> el).sum();
Jackkobec
la source
0

Un peu surpris de voir Aucune des réponses ci-dessus ne considère que l'utilisation d'un pool de threads peut être plusieurs fois plus rapide. Ici, parallelutilise un pool de threads fork-join et divise automatiquement le flux en plusieurs parties et les exécute en parallèle, puis fusionne. Si vous vous souvenez simplement de la ligne de code suivante, vous pouvez l'utiliser à de nombreux endroits.

Le prix du code court et doux le plus rapide est donc décerné à -

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

Disons que vous voulez faire sum of squares, alors Arrays.stream (nums) .parallel (). Map (x-> x * x) .reduce (0, (a, b) -> a + b). L'idée est que vous pouvez toujours effectuer une réduction, sans carte.

sapy
la source
Pas forcément le plus rapide. Loop surclassera le petit N. Voir mon article plus long avec des détails.
gerardw
-1
 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);

     }
  } 
BLaaaaaa
la source
1
mec c'est somme = somme + a [i];
Maksim Kniazev
-1
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);

    }

}
TRC
la source
-3

Depuis Java 8 L'utilisation d'expressions lambda est devenue disponible.

Regarde ça:

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

Compact:

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

Préférer:

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.

L'Archon
la source
1
Fonctionne: int [] nums = {1,2}; final int [] somme = {0}; ArrayList <Integer> list = new ArrayList <Integer> (); for (int each: nums) {list.add (each); } list.stream (). forEach (each -> {sum [0] + = each;});
Zhurov Konstantin