Comment additionner une liste d'entiers avec des java streams?

Je veux résumer une liste d'entiers. Cela fonctionne comme suit, mais la syntaxe ne semble pas correcte. Le code pourrait-il être optimisé?

Map<String, Integer> integers;
integers.values().stream().mapToInt(i -> i).sum();

Cela fonctionnera, mais le i -> ifait un déballage automatique, c'est pourquoi cela "semble" étrange. L'un des éléments suivants fonctionnera et expliquera mieux ce que le compilateur fait sous le capot avec votre syntaxe d'origine:

integers.values().stream().mapToInt(i -> i.intValue()).sum();
integers.values().stream().mapToInt(Integer::intValue).sum();

Je suggère 2 options supplémentaires:

integers.values().stream().mapToInt(Integer::intValue).sum();
integers.values().stream().collect(Collectors.summingInt(Integer::intValue));

Le second utilise le Collectors.summingInt()collecteur, il y a aussi un summingLong()collecteur avec lequel vous utiliseriez mapToLong.

Et une troisième option: Java 8 introduit un très efficace LongAdder accumulateur conçu pour accélérer la synthèse dans des flux parallèles et des environnements multi-threads. Ici, voici un exemple d'utilisation:

LongAdder a = new LongAdder();
map.values().parallelStream().forEach(a::add);
sum = a.intValue();

À partir des documents

Opérations de réduction Une opération de réduction (également appelée pli) prend une séquence d'éléments d'entrée et les combine en un seul résultat récapitulatif par application répétée d'une opération de combinaison, telle que trouver la somme ou le maximum d'un ensemble de nombres, ou accumuler des éléments dans une liste. Les classes de flux ont plusieurs formes d'opérations de réduction générales, appelées reduction () et collect (), ainsi que plusieurs formes de réduction spécialisées telles que sum (), max () ou count ().

Bien sûr, de telles opérations peuvent être facilement implémentées sous forme de simples boucles séquentielles, comme dans:

int sum = 0;
for (int x : numbers) {
   sum += x;
}

Cependant, il existe de bonnes raisons de préférer une opération de réduction à une accumulation mutative telle que la précédente. Non seulement une réduction est "plus abstraite" - elle opère sur le flux dans son ensemble plutôt que sur des éléments individuels - mais une opération de réduction correctement construite est intrinsèquement parallélisable, tant que la ou les fonctions utilisées pour traiter les éléments sont associatives. et apatrides. Par exemple, étant donné un flux de nombres dont nous voulons trouver la somme, nous pouvons écrire:

int sum = numbers.stream().reduce(0, (x,y) -> x+y);

ou:

int sum = numbers.stream().reduce(0, Integer::sum);

Ces opérations de réduction peuvent s'exécuter en toute sécurité en parallèle avec presque aucune modification:

int sum = numbers.parallelStream().reduce(0, Integer::sum);

Donc, pour une carte que vous utiliseriez:

integers.values().stream().mapToInt(i -> i).reduce(0, (x,y) -> x+y);

Ou:

integers.values().stream().reduce(0, Integer::sum);

Vous pouvez utiliser la méthode de réduction:

long sum = result.stream().map(e -> e.getCreditAmount()).reduce(0L, (x, y) -> x + y);

ou

long sum = result.stream().map(e -> e.getCreditAmount()).reduce(0L, Integer::sum);

Vous pouvez utiliser reduce()pour additionner une liste d'entiers.

int sum = integers.values().stream().reduce(0, Integer::sum);

Vous pouvez utiliser la méthode collect pour ajouter une liste d'entiers.

List<Integer> list = Arrays.asList(2, 4, 5, 6);
int sum = list.stream().collect(Collectors.summingInt(Integer::intValue));

Ce serait le moyen le plus court de résumer le inttableau de type (pour longtableau LongStream, pour doubletableau DoubleStream, etc.). Cependant, tous les types d'entiers primitifs ou à virgule flottante ne sont pas Streamimplémentés.

IntStream.of(integers).sum();

Que cela aide ceux qui ont des objets sur la liste.

Si vous avez une liste d'objets et que vous souhaitez additionner des champs spécifiques de cet objet, utilisez ce qui suit.

List<ResultSom> somList = MyUtil.getResultSom();
BigDecimal result= somList.stream().map(ResultSom::getNetto).reduce(
                                             BigDecimal.ZERO, BigDecimal::add);

J'ai déclaré une liste d'entiers.

ArrayList<Integer> numberList = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));

Vous pouvez essayer d'utiliser ces différentes méthodes ci-dessous.

En utilisant mapToInt

int sum = numberList.stream().mapToInt(Integer::intValue).sum();

En utilisant summarizingInt

int sum = numberList.stream().collect(Collectors.summarizingInt(Integer::intValue)).getSum();

En utilisant reduce

int sum = numberList.stream().reduce(Integer::sum).get().intValue();

class Pojo{
    int num;

    public Pojo(int num) {
        super();
        this.num = num;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

List<Pojo> list = new ArrayList<Pojo>();
            list.add(new Pojo(1));
            list.add(new Pojo(5));
            list.add(new Pojo(3));
            list.add(new Pojo(4));
            list.add(new Pojo(5));

            int totalSum = list.stream().mapToInt(pojo -> pojo.getNum()).sum();
            System.out.println(totalSum);

La plupart des aspects sont couverts. Mais il pourrait être nécessaire de trouver l'agrégation d'autres types de données en dehors d'Integer, Long (pour lequel un support de flux spécialisé est déjà présent). Par exemple, stram avec BigInteger Pour un tel type, nous pouvons utiliser réduire l'opération comme

list.stream (). réduire ((bigInteger1, bigInteger2) -> bigInteger1.add (bigInteger2))