Wie summiere ich eine Liste von ganzen Zahlen mit Java-Streams?

Ich möchte eine Liste von ganzen Zahlen zusammenfassen. Es funktioniert wie folgt, aber die Syntax fühlt sich nicht richtig an. Könnte der Code optimiert werden?

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

Dies wird funktionieren, aber das i -> imacht ein automatisches Unboxing, weshalb es sich seltsam "anfühlt". Beides funktioniert und erklärt besser, was der Compiler unter der Haube mit Ihrer ursprünglichen Syntax tut:

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

Ich schlage 2 weitere Optionen vor:

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

Der zweite verwendet Collectors.summingInt()Collector, es gibt auch einen summingLong()Collector, mit dem Sie verwenden würden mapToLong.

Und eine dritte Option: Java 8 führt einen sehr effektiven LongAdderAkkumulator ein, der die Zusammenfassung in parallelen Streams und Multithread-Umgebungen beschleunigt. Hier ist ein Beispiel:

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

Aus den Dokumenten

Reduktionsoperationen Eine Reduktionsoperation (auch als Fold bezeichnet) nimmt eine Folge von Eingabeelementen und kombiniert sie zu einem einzigen zusammenfassenden Ergebnis, indem wiederholt eine Kombinationsoperation angewendet wird, z. B. das Ermitteln der Summe oder des Maximums eines Satzes von Zahlen oder das Akkumulieren von Elementen eine Liste. Die Streams-Klassen haben mehrere Formen allgemeiner Reduktionsoperationen, die als redu () und collect () bezeichnet werden, sowie mehrere spezialisierte Reduktionsformen wie sum (), max () oder count ().

Natürlich können solche Operationen leicht als einfache sequentielle Schleifen implementiert werden, wie in:

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

Es gibt jedoch gute Gründe, eine Reduktionsoperation einer mutativen Akkumulation wie der obigen vorzuziehen. Eine Reduktion ist nicht nur "abstrakter" - sie wirkt sich eher auf den gesamten Stream als auf einzelne Elemente aus -, sondern eine ordnungsgemäß aufgebaute Reduktionsoperation ist von Natur aus parallelisierbar, solange die zur Verarbeitung der Elemente verwendeten Funktionen assoziativ sind und staatenlos. Wenn wir beispielsweise einen Zahlenstrom angeben, für den wir die Summe ermitteln möchten, können wir schreiben:

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

oder:

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

Diese Reduktionsvorgänge können ohne nahezu Änderung sicher parallel ausgeführt werden:

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

Für eine Karte würden Sie also Folgendes verwenden:

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

Oder:

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

Sie können die Reduzierungsmethode verwenden:

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

oder

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

Sie können reduce()eine Liste von Ganzzahlen summieren.

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

Mit der Methode collect können Sie eine Liste von Ganzzahlen hinzufügen.

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

Dies wäre der kürzeste Weg, um den intTyp Array (für longArray LongStream, für doubleArray DoubleStreamusw.) zusammenzufassen. Allerdings haben nicht alle primitiven Ganzzahl- oder Gleitkommatypen die StreamImplementierung.

IntStream.of(integers).sum();

Möge dies denen helfen, die Objekte auf der Liste haben.

Wenn Sie eine Liste von Objekten haben und bestimmte Felder dieses Objekts summieren möchten, verwenden Sie Folgendes.

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

Ich habe eine Liste von Ganzzahlen deklariert.

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

Sie können diese verschiedenen Methoden unten verwenden.

Verwenden von mapToInt

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

Verwenden von summarizingInt

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

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

Die meisten Aspekte werden behandelt. Es könnte jedoch erforderlich sein, die Aggregation anderer Datentypen außer Integer, Long (für die bereits spezielle Stream-Unterstützung vorhanden ist) zu finden. Zum Beispiel stram mit BigInteger Für einen solchen Typ können wir Reduktionsoperationen wie verwenden

list.stream (). redu ((bigInteger1, bigInteger2) -> bigInteger1.add (bigInteger2))