How to sum a list of integers with java streams?

Question

I want to sum a list of Integers. It works as follows, but the syntax does not feel right. Could the code be optimized?

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

Transatlantic

"but the syntax does not feel right" What makes you think that? This is the usual idiom. Maybe you want to use mapToLong to avoid overflows, depending on the values your map can have. – Processional

@JBNizet I find i -> i very clear, personally. Well, yes you need to know that the value will be automatically unboxed, but it's true since Java 5... – Processional

@AlexisC. it's understandable because it's passed to mapToInt(), and because I'm an experienced developer. But i -> i, without context, looks like a noop. Integer::intValue is more verbose, but makes the unboxing operation explicit. – Protuberancy

@JBNizet People that calls the method foo(int i) do not write foo(myInteger.intValue()); each time they call it (or at least I expect not!!). I agree with you that Integer::intValue is more explicit but I think the same applies here. People should just learn it once and then you're done :-). It's not like if it was some magic obfuscation. – Processional

@JB Nizet: well, i -> i looks like a no-op and conceptionally, it is a no-op. Sure, under the hood Integer.intValue() gets called, but even deeper under the hood, that methods gets inlined to become exactly the no-op that it looks like in the source code. Integer::intValue has the bonus point of not creating a synthetic method in the byte code but it’s not what should drive your decision of how to organize your source code. – Conciliatory

@Conciliatory that's my point: it looks like a noop, and the reader thus has a good chance of asking himself why a noop is used in the code every time he/she will read that code. That's why I prefer Integer::intValue: it says exactly and explicitely what the operation is doing. – Protuberancy

Integer overflow and underflow can happen even with 1 value which is close to the limit. Comments about BigInt aren't pointless!!! – Fetch

Answer 1

You can use collect method to add list of integers.

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

Emaciation

Answer 2

This will work, but the i -> i is doing some automatic unboxing which is why it "feels" strange. mapToInt converts the stream to an IntStream "of primitive int-valued elements". Either of the following will work and better explain what the compiler is doing under the hood with your original syntax:

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

Heins

What if we have a BigInteger :) ? – Cosmonaut

One simple option isBigDecimal sum = numbers.stream().reduce(BigDecimal.ZERO, BigDecimal::add); – Senskell

he specifically asked for Integers – Jimmy

How do you sum to a particular value? for example, you have a list of integers but you want to sum till you get the value 20. – Uncle

@JoaquínL.Robles basic types are easy to overflow and underflow with most popular languages including Java's Integer. – Fetch

@DaviesTobialex That is an entirely different question, and would be more appropriate to be asked as such rather than as a comment. :-) – Burnie

Answer 3

I suggest 2 more options:

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

The second one uses Collectors.summingInt() collector, there is also a summingLong() collector which you would use with mapToLong.

---

And a third option: Java 8 introduces a very effective LongAdder accumulator designed to speed-up summarizing in parallel streams and multi-thread environments. Here, here's an example use:

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

Blagoveshchensk

Answer 4

From the docs

Reduction operations A reduction operation (also called a fold) takes a sequence of input elements and combines them into a single summary result by repeated application of a combining operation, such as finding the sum or maximum of a set of numbers, or accumulating elements into a list. The streams classes have multiple forms of general reduction operations, called reduce() and collect(), as well as multiple specialized reduction forms such as sum(), max(), or count().

Of course, such operations can be readily implemented as simple sequential loops, as in:

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

However, there are good reasons to prefer a reduce operation over a mutative accumulation such as the above. Not only is a reduction "more abstract" -- it operates on the stream as a whole rather than individual elements -- but a properly constructed reduce operation is inherently parallelizable, so long as the function(s) used to process the elements are associative and stateless. For example, given a stream of numbers for which we want to find the sum, we can write:

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

or:

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

These reduction operations can run safely in parallel with almost no modification:

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

So, for a map you would use:

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

Or:

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

Proliferation

What the OP has is much better, and also clearer. This code would involve a whole loat of unboxing and boxing operations. – Protuberancy

@JBNizet Unless the escape analysis eliminates the boxing. You would have to try it to see if it can. – Calia

@PeterLawrey I'd still prefer to operate on primitive values directly, use what the OP has, or Sasha's first comment solution. – Protuberancy

@JBNizet if the numbers are already in a map, the values don.t need to be boxed. – Proliferation

(x,y) -> x+y needs to unbox x and y, sum them, and then box the result. And start again to add the result with the next element of the stream, and again and again. – Protuberancy

Integer::sum suffers from the same problem. And if you use mapToInt() to have an IntStream, calling sum() on it is more straightforward than calling reduce(). – Protuberancy

@JBNizet I'm still confused, why does boxing still happen when Integer::sum is called on a stream of Integers? Does the boxing happen inside the sum method? – Proliferation

See docs.oracle.com/javase/8/docs/api/java/lang/…. The two arguments of Integer.sum() are of type int. So the two Integers from the stream must be unboxed to be passed as arguments to the method. The method returns an int, but reduce() takes a BinaryOperator<Integer> as argument, which thus returns an Integer. So the result of the sum has to be boxed to Integer. – Protuberancy

Thanks! I used this for sum BigDecimal numbers: BigDecimal sum = in.getItems().stream().map(it -> (it.getValue() != null) ? it.getValue() : BigDecimal.ZERO).reduce(BigDecimal.ZERO, BigDecimal::add); – Whether

Answer 5

You can use reduce method:

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

or

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

Mckeown

There is already such accumulator for int, it is Integer::sum – Blagoveshchensk

You're returning a long, so it would be better Long::sum than Integer::sum. – Unclassified

Answer 6

You can use reduce() to sum a list of integers.

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

Lune

Answer 7

I have declared a list of Integers.

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

You can try using these different ways below.

Using mapToInt

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

Using summarizingInt

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

Using reduce

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

Poulin

Answer 8

May this help those who have objects on the list.

If you have a list of objects and wanted to sum specific fields of this object use the below.

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

Dittmer

Answer 9

This would be the shortest way to sum up int type array (for long array LongStream, for double array DoubleStream and so forth). Not all the primitive integer or floating point types have the Stream implementation though.

IntStream.of(integers).sum();

Subsidiary

Unfortunately we don't have any int-array. So IntStream.of() won't work for this problem, unless we're making something spooky like this: IntStream.of( integers.values().stream().mapToInt( Integer::intValue ).toArray() ).sum(); – Inalienable

No need, this would be enough integers.values().stream().mapToInt( Integer::intValue ).sum(). – Subsidiary

Answer 10

There is one more option no one considered here and it reflects on usage of multi-core environment. If you want to use its advantages, then next code should be used instead of the other mentioned solutions:

int sum = integers.values().parallelStream().mapToInt(Integer::intValue)
        .reduce(0, Integer::sum, Integer::sum);

This solution is similar to other ones, but please notice the third argument in reduce. It tells compiler what to do with partial summaries calculated in different chunks of the stream, by different threads. Also instead of stream(), the parallelStream() is used. In this case it would just summarize it. The other option to put as third argument is (i, j) -> i + j, which means that it would add a value of a stream chunk (j) to the current value (i) and use it as a current value for the next stream chunk until all partial results are processed.

Even when using plain stream() it is useful to tell to reduce what to do with stream chunks' summaries, just in case someone, or you, would like to parallelize it in the future. The initial development is best time for that, since later on you need to remember what this is supposed to be and need to spend some time in understanding the purpose of that code again.

And of course instead of method reference operator you can have different dialect of lambda. I prefer it this way as more compact and still easy readable.

Also remember this can be used for more complex calculations too, but always be aware there are no guarantees about sequence and deployment of stream elements to threads.

Noyes

Answer 11

Unfortunately looks like the Stream API only returns normal streams from, say, List<Integer>#stream(). Guess they're pretty much forced to because of how generics work.

These normal Streams are of generic objects so don't have specialized methods like sum() etc. so you have to use the weird re-stream "looks like a no-op" conversion by default to get to those methods... .mapToInt(i -> i).

Another option is using "Eclipse Collections" which are like an expanded java Stream API

IntLists.immutable.ofAll(integers.values()).sum();

Sudiesudnor

Answer 12

IntStream.of(1, 2, 23).sum();
IntStream.of(1, 2, 23,1, 2, 23,1, 2, 23).max().getAsInt();

Dave

Answer 13

Using summingInt

Integer sum= listInt.stream().collect(Collectors.summingInt(Integer::intValue));

Nepheline