Obtenir la somme d'un tableau en Java

Pour calculer le total d’un int[] en Java, utilisez Arrays.stream(numbers).sum() pour une solution concise intégrée au langage, ou additionnez chaque valeur avec une boucle for si vous souhaitez contrôler explicitement le parcours. Les tableaux Java ne disposent pas d’une méthode d’instance sum() ; Arrays.stream(int[]) transforme leurs valeurs en IntStream, qui fournit sum() et reduce().
Additionner un tableau fait partie des opérations de base sur les données dans le Tutoriel Java, qui ordonne les guides sur les tableaux et les collections des bases jusqu’aux streams.

Les exemples ci-dessous utilisent les mêmes six valeurs, dont la somme arithmétique est 149. Chaque programme est autonome et peut être enregistré sous le nom SimpleTesting.java.

Calculer la somme d’un tableau int[] avec une boucle for

Une boucle classique rend chaque étape visible : initialiser l’accumulateur, parcourir chaque indice et ajouter l’élément correspondant. C’est une solution simple à suivre si vous souhaitez comprendre le calcul ou ajouter d’autres opérations pendant le parcours.

Ce programme additionne les six valeurs de numbers et affiche leur total. La condition de la boucle utilise numbers.length, et le nom du tableau est employé de façon cohérente pour sa longueur comme pour accéder à ses éléments.

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = 0;

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

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Calculer la somme d’un tableau int[] avec un flux parallèle et reduce

Appelez parallel() sur l’IntStream renvoyé par Arrays.stream(numbers) pour utiliser un flux parallèle. La méthode reduce à deux arguments prend une valeur d’identité (0) et une opération d’addition. L’addition étant associative, les sommes partielles peuvent être combinées pour obtenir le même résultat. Pour un tableau court, préférez la version séquentielle, sauf si le traitement parallèle convient au reste de la charge de travail ; le parallélisme n’accélère pas automatiquement un calcul de petite taille.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = Arrays.stream(numbers)
        .parallel()
        .reduce(0, (left, right) -> left + right);

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Calculer la somme d’un tableau int[] avec Arrays.stream(...).reduce(...)

Pour obtenir un flux séquentiel, omettez parallel(). Arrays.stream(int[]) renvoie toujours un IntStream ; reduce(0, Integer::sum) commence par la valeur d’identité et combine chaque valeur primitive par addition. Cette valeur d’identité permet de définir le résultat de l’opération même lorsqu’il n’y a aucune valeur à combiner.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = Arrays.stream(numbers).reduce(0, Integer::sum);

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Calculer la somme d’un tableau int[] avec Arrays.stream(...).sum()

Pour une addition, sum() exprime l’intention plus directement qu’une réduction. Cette opération terminale de l’IntStream créé à partir du tableau renvoie un total de type int.

Comme cette méthode renvoie un int, le total est calculé avec l’arithmétique entière sur 32 bits de Java. Si la somme mathématique risque de dépasser la plage d’un int, convertissez le flux avant l’addition, par exemple avec Arrays.stream(numbers).asLongStream().sum(). Pour couvrir cette plage avec une boucle classique, il faut également utiliser un accumulateur long et élargir les valeurs lors de l’addition.

import java.util.Arrays;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = Arrays.stream(numbers).sum();

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Calculer la somme d’un tableau int[] avec IntStream.of(...).sum()

IntStream.of(numbers) est une autre façon directe de créer un IntStream à partir d’un int[]. Son opération sum() renvoie le même total que Arrays.stream(numbers).sum(). Choisissez la forme qui s’intègre le plus naturellement à votre code.

import java.util.stream.IntStream;

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total = IntStream.of(numbers).sum();

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149

Calculer la somme d’un tableau int[] avec une boucle for compacte

La boucle ci-dessous regroupe l’initialisation, la condition de continuation et l’accumulation dans l’en-tête du for, puis parcourt le tableau du dernier indice au premier. Cette syntaxe est valide en Java, mais le corps vide et la décrémentation dans l’expression de mise à jour la rendent plus difficile à lire qu’une boucle classique. Préférez la forme plus claire, sauf si la compacité présente un intérêt particulier.

public class SimpleTesting {
  public static void main(String[] args) {
    int[] numbers = {12, 34, 45, 21, 33, 4};
    int total;
    int i;

    for (total = 0, i = numbers.length - 1;
         i >= 0;
         total += numbers[i--]) {
      // Accumulation happens in the loop update expression.
    }

    System.out.println("Array Sum = " + total);
  }
}

Array Sum = 149