Zahlen mit Java-Streams summieren

1. Einleitung

In diesem kurzen Tutorial zeigen wir verschiedene Möglichkeiten zur Berechnung der Summe von Ganzzahlen mithilfe der Stream-API .

Der Einfachheit halber werden in unseren Beispielen Ganzzahlen verwendet. Wir können die gleichen Methoden jedoch auch auf Longs und Doubles anwenden.

2. Verwenden von Stream.reduce ()

Stream.reduce () ist eine Terminaloperation, die eine Reduzierung der Elemente des Streams durchführt .

Es wendet einen binären Operator (Akkumulator) auf jedes Element im Stream an, wobei der erste Operand der Rückgabewert der vorherigen Anwendung und der zweite das aktuelle Stream-Element ist.

Bei der ersten Methode zur Verwendung der Methode redu () ist die Akkumulatorfunktion ein Lambda-Ausdruck, der zwei Ganzzahlwerte hinzufügt und einen Ganzzahlwert zurückgibt :

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

Auf die gleiche Weise können wir eine bereits vorhandene Java-Methode verwenden :

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

Oder wir können unsere benutzerdefinierte Methode definieren und verwenden:

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

Dann können wir diese Funktion als Parameter an die redu () -Methode übergeben:

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

3. Verwenden von Stream.collect ()

Die zweite Methode zum Berechnen der Summe einer Liste von ganzen Zahlen ist die Verwendung der Terminaloperation collect () :

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

In ähnlicher Weise bietet die Collectors- Klasse die Methoden summingLong () und summingDouble () , um die Summen von Longs bzw. Doubles zu berechnen.

4. Verwenden von IntStream.sum ()

Die Stream-API stellt uns die Zwischenoperation mapToInt () zur Verfügung, mit der unser Stream in ein IntStream- Objekt konvertiert wird .

Diese Methode verwendet einen Mapper als Parameter, mit dem die Konvertierung durchgeführt wird. Anschließend können wir die sum () -Methode aufrufen , um die Summe der Elemente des Streams zu berechnen.

Sehen wir uns ein kurzes Beispiel an, wie wir es verwenden können:

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

Auf die gleiche Weise können wir die Methoden mapToLong () und mapToDouble () verwenden, um die Summen von Longs bzw. Doubles zu berechnen.

5. Verwenden von Stream # sum mit Map

Um die Summe der Werte einer Berechnung Map - Datenstruktur zum einen schaffen wir einen Strom von den Werten dieser Karte , dann setzen wir eine der Methoden , die zuvor verwendeten wir.

Zum Beispiel mit IntStream.sum () :

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

6. Verwenden von Stream # sum mit Objekten

Stellen wir uns vor, wir haben eine Liste von Objekten und möchten die Summe aller Werte eines bestimmten Feldes dieser Objekte berechnen .

Zum Beispiel:

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 } 

Stellen wir uns als nächstes vor, wir möchten den Gesamtpreis aller Artikel der folgenden Liste berechnen:

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

In diesem Fall müssen wir zur Berechnung der Summe mit den in den vorherigen Beispielen gezeigten Methoden die map () -Methode aufrufen , um unseren Stream in einen Stream von Ganzzahlen umzuwandeln .

Daher können wir Stream.reduce (), Stream.collect () und IntStream.sum () verwenden , um die Summe zu berechnen:

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. Verwenden von Stream # sum mit String

Nehmen wir an, wir haben ein String- Objekt, das einige Ganzzahlen enthält.

Um die Summe dieser Ganzzahlen zu berechnen, müssen wir zuerst diesen String in ein Array konvertieren , dann die nicht ganzzahligen Elemente herausfiltern und schließlich die verbleibenden Elemente dieses Arrays in Zahlen konvertieren .

Lassen Sie uns all diese Schritte in Aktion sehen:

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

In diesem Tutorial haben wir verschiedene Methoden zur Berechnung der Summe einer Liste von Ganzzahlen mithilfe der Stream-API kennengelernt. Außerdem haben wir diese Methoden verwendet, um die Summe der Werte eines bestimmten Felds einer Liste von Objekten, die Summe der Werte einer Karte sowie die Zahlen innerhalb eines bestimmten String- Objekts zu berechnen .

Wie immer ist der vollständige Code auf GitHub verfügbar.