Addition de nombres avec des flux Java

1. Introduction

Dans ce rapide didacticiel, nous montrerons différentes façons de calculer la somme des entiers, à l'aide de l'API Stream .

Par souci de simplicité, nous utiliserons des entiers dans nos exemples. Cependant, nous pouvons également appliquer les mêmes méthodes aux longs et aux doubles.

2. Utilisation de Stream.reduce ()

Stream.reduce () est une opération de terminal qui effectue une réduction sur les éléments du flux .

Il applique un opérateur binaire (accumulateur) à chaque élément du flux, où le premier opérande est la valeur de retour de l'application précédente et le second est l'élément de flux actuel.

Dans la première méthode d'utilisation de la méthode reduction () , la fonction d'accumulateur est une expression lambda qui ajoute deux valeurs Integer et renvoie une valeur Integer :

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .reduce(0, (a, b) -> a + b);

De la même manière, nous pouvons utiliser une méthode Java déjà existante :

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .reduce(0, Integer::sum);

Ou nous pouvons définir et utiliser notre méthode personnalisée:

public class ArithmeticUtils { public static int add(int a, int b) { return a + b; } } 

Ensuite, nous pouvons passer cette fonction en paramètre à la méthode reduction () :

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .reduce(0, ArithmeticUtils::add); 

3. Utilisation de Stream.collect ()

La deuxième méthode pour calculer la somme d'une liste d'entiers consiste à utiliser l' opération de terminal collect () :

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .collect(Collectors.summingInt(Integer::intValue));

De même, la classe Collectors fournit les méthodes summingLong () et summingDouble () pour calculer respectivement les sommes des longs et des doubles.

4. Utilisation de IntStream.sum ()

L'API Stream nous fournit l' opération intermédiaire mapToInt () , qui convertit notre flux en objet IntStream .

Cette méthode prend un mappeur comme paramètre, qu'il utilise pour faire la conversion, puis, nous pouvons appeler la méthode sum () pour calculer la somme des éléments du flux.

Voyons un exemple rapide de la façon dont nous pouvons l'utiliser:

List integers = Arrays.asList(1, 2, 3, 4, 5); Integer sum = integers.stream() .mapToInt(Integer::intValue) .sum();

De la même manière, nous pouvons utiliser les méthodes mapToLong () et mapToDouble () pour calculer respectivement les sommes des longs et des doubles.

5. Utilisation de Stream # sum avec Map

Pour calculer la somme des valeurs d'une structure de données Map , nous créons d'abord un flux à partir des valeurs de cette Map , puis nous appliquons l'une des méthodes que nous avons utilisées précédemment.

Par exemple, en utilisant IntStream.sum () :

Integer sum = map.values() .stream() .mapToInt(Integer::valueOf) .sum();

6. Utilisation de Stream # sum avec des objets

Imaginons que nous ayons une liste d'objets et que nous voulions calculer la somme de toutes les valeurs d'un champ donné de ces objets.

Par exemple:

public class Item { private int id; private Integer price; public Item(int id, Integer price) { this.id = id; this.price = price; } // Standard getters and setters } 

Ensuite, imaginons que nous souhaitons calculer le prix total de tous les articles de la liste suivante:

Item item1 = new Item(1, 10); Item item2 = new Item(2, 15); Item item3 = new Item(3, 25); Item item4 = new Item(4, 40); List items = Arrays.asList(item1, item2, item3, item4);

Dans ce cas, afin de calculer la somme en utilisant les méthodes présentées dans les exemples précédents, nous devons appeler la méthode map () pour convertir notre flux en un flux d'entiers .

En conséquence, nous pouvons utiliser Stream.reduce (), Stream.collect () et IntStream.sum () pour calculer la somme:

Integer sum = items.stream() .map(x -> x.getPrice()) .reduce(0, ArithmeticUtils::add); 
Integer sum = items.stream() .map(x -> x.getPrice()) .reduce(0, Integer::sum);
Integer sum = items.stream() .map(item -> item.getPrice()) .reduce(0, (a, b) -> a + b);
Integer sum = items.stream() .map(x -> x.getPrice()) .collect(Collectors.summingInt(Integer::intValue));
items.stream() .mapToInt(x -> x.getPrice()) .sum();

7. Utilisation de Stream # sum avec String

Supposons que nous ayons un objet String contenant des entiers.

Pour calculer la somme de ces entiers, tout d'abord, nous devons convertir cette chaîne en un tableau , puis nous devons filtrer les éléments non entiers , et enfin, convertir les éléments restants de ce tableau en nombres.

Voyons toutes ces étapes en action:

String string = "Item1 10 Item2 25 Item3 30 Item4 45"; Integer sum = Arrays.stream(string.split(" ")) .filter((s) -> s.matches("\\d+")) .mapToInt(Integer::valueOf) .sum();

8. Conclusion

Dans ce didacticiel, nous avons vu plusieurs méthodes de calcul de la somme d'une liste d'entiers à l'aide de l'API Stream. De plus, nous avons utilisé ces méthodes pour calculer la somme des valeurs d'un champ donné d'une liste d'objets, la somme des valeurs d'une carte, ainsi que les nombres dans un objet String donné .

Comme toujours, le code complet est disponible à l'adresse over sur GitHub.