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

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.

Dans java-8 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.*;

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

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

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

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

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;

int sum = 0;

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

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 < myArray.length; i++)
  sum += myArray[i];
}

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

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

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

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.

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

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

Ç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

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

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

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.

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

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

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

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.

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

    }

}

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.