**Get started with Spring 5 and Spring Boot 2, through the ***Learn Spring* course:

*Learn Spring*course:

**>> CHECK OUT THE COURSE**

Last modified: April 8, 2020

We usually use the Java Stream API for processing collections of data.

One nice feature is support for operations on numeric streams, like the *sum *operation. However, **we cannot process all numeric types in this way.**

In this tutorial, we'll see how to perform the *sum* operation on streams of numbers like *BigDecimal*.

The Stream API provides streams of numbers, including *IntStream, DoubleStream, *and* LongStream. *

Let's remind ourselves how these work by *c*reating a numeric stream. Then, we'll calculate its total with *IntStream#sum*:

```
IntStream intNumbers = IntStream.range(0, 3);
assertEquals(3, intNumbers.sum());
```

We can do a similar thing starting with a list of *Double*s. By using streams, we can convert from an object stream to a *DoubleStream* using *mapToDouble*:

```
List<Double> doubleNumbers = Arrays.asList(23.48, 52.26, 13.5);
double result = doubleNumbers.stream()
.mapToDouble(Double::doubleValue)
.sum();
assertEquals(89.24, result, .1);
```

So, it would be useful if we could sum up a collection of *BigDecimal *numbers the same way.

**Unfortunately, there isn't a BigDecimalStream.** So, we need another solution.

Instead of relying on *sum*, we can use *Stream.reduce:*

```
Stream<Integer> intNumbers = Stream.of(5, 1, 100);
int result = intNumbers.reduce(0, Integer::sum);
assertEquals(106, result);
```

**This works on anything that can be logically added together**, including *BigDecimal*:

```
Stream<BigDecimal> bigDecimalNumber =
Stream.of(BigDecimal.ZERO, BigDecimal.ONE, BigDecimal.TEN);
BigDecimal result = bigDecimalNumber.reduce(BigDecimal.ZERO, BigDecimal::add);
assertEquals(11, result);
```

The *reduce* method takes two parameters:

*Identity*– is the equivalent of*0*– it is the starting value for the reduction*Accumulator function*– takes two parameters, the result so far, and the next element of the stream

In this article, we looked at how to find the sum of some numbers in a numeric *Stream*. Then we discovered how to use *reduce* as an alternative.

Using *reduce* allows us to sum a collection of *BigDecimal* numbers. It can be applied to any other type.

As always, the code for the examples is available over on GitHub.

Follow the Java Category

Follow the Java category to get regular info about the new articles and tutorials we publish here.