How do you find the sum of all the numbers in an array in Java?

Question

I'm having a problem finding the sum of all of the integers in an array in Java. I cannot find any useful method in the Math class for this.

Moffett

Write your own, the code to do it is 2-3 lines long. – Phenacaine

Unfortunately the above (and following) "answers" are "The Java Way" :-/ You could use the Functional Java library, but it is so cumbersome to deal with the Java syntax. – Symphony

I know this question is extremely old, but the answer by msayag below seems like it should be marked as the accepted answer. – Vanessa

The problem with writing you own is that it is a loop. When you take a sum of 3 numbers you should be able to do it in one instruction. – Echinate

Answer 1

In java-8 you can use streams:

int[] a = {10,20,30,40,50};
int sum = IntStream.of(a).sum();
System.out.println("The sum is " + sum);

Output:

The sum is 150.

It's in the package java.util.stream

import java.util.stream.*;

Draughtboard

What if array contains large numbers and the sum is out of int scope? – Conduction

In that case you can use LongStream, either as long sum = IntStream.of(a).asLongStream().sum(); or long sum = LongStream.of(a).sum(); – Draughtboard

Is there any considerable speed advantage in using streams? – Conversationalist

If your sum would not fit long, one should sum pair wise (divide and conquer), because summing smaller BigDecimals is faster. – Bratcher

Do you have a solution to do the same, on an array of doubles? If you try it on a double you'll get the err, "method java.util.stream.IntStream.of(int...) is not applicable (varargs mismatch; double[] cannot be converted to int)" – Surcingle

@HosseinRahimi java.util.stream.DoubleStream.of(a).sum(); – Kassia

Answer 2

If you're using Java 8, the Arrays class provides a stream(int[] array) method which returns a sequential IntStream with the specified int array. It has also been overloaded for double and long arrays.

int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum(); //prints 10

It also provides a method stream(int[] array, int startInclusive, int endExclusive) which permits you to take a specified range of the array (which can be useful) :

int sum = Arrays.stream(new int []{1,2,3,4}, 0, 2).sum(); //prints 3

Finally, it can take an array of type T. So you can per example have a String which contains numbers as an input and if you want to sum them just do :

int sum = Arrays.stream("1 2 3 4".split("\\s+")).mapToInt(Integer::parseInt).sum();

Guaco

Answer 3

This is one of those simple things that doesn't (AFAIK) exist in the standard Java API. It's easy enough to write your own.

Other answers are perfectly fine, but here's one with some for-each syntactic sugar.

int someArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;

for (int i : someArray)
    sum += i;

Also, an example of array summation is even shown in the Java 7 Language Specification. The example is from Section 10.4 - Array Access.

class Gauss {
    public static void main(String[] args) {
        int[] ia = new int[101];
        for (int i = 0; i < ia.length; i++) ia[i] = i;
        int sum = 0;
        for (int e : ia) sum += e;
        System.out.println(sum);
    }
}

Phenacaine

But this doesn't add all the numbers in one fell swoop. It is inefficient. – Echinate

I can't imagine it being less efficient than the streams solution. – Wikiup

There is absolutely no better way to determine the sum of a set of arbitrary numbers than by adding up all the numbers. O(n) is the best you can do. – Domineer

A stream is not processed "in one fell swoop". It iterates over the values and processes them one by one. – Catchup

Answer 4

You can't. Other languages have some methods for this like array_sum() in PHP, but Java doesn't.

Just..

int[] numbers = {1,2,3,4};
int sum = 0;
for( int i : numbers) {
    sum += i;
}

System.out.println(sum);

Claudie

I miss you .NET Sum(IEnumerable<Int32>) msdn.microsoft.com/en-us/library/… – Inelastic

Answer 5

In Apache Math : There is StatUtils.sum(double[] arr)

Janenejanenna

Answer 6

The only point I would add to previous solutions is that I would use a long to accumulate the total to avoid any overflow of value.

int[] someArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE};
long sum = 0;

for (int i : someArray)
    sum += i;

Schoolteacher

Answer 7

int sum = 0;

for (int i = 0; i < yourArray.length; i++)
{
  sum = sum + yourArray[i];
}

Katelin

You can make it even nicer with a for-each loop (introduced in Java 1.5). – Phenacaine

Answer 8

In Java 8

Code:

   int[] array = new int[]{1,2,3,4,5};
   int sum = IntStream.of(array).reduce( 0,(a, b) -> a + b);
   System.out.println("The summation of array is " + sum);

  System.out.println("Another way to find summation :" + IntStream.of(array).sum());

Output:

The summation of array is 15
Another way to find summation :15

Explanation:

In Java 8, you can use reduction concept to do your addition.

Read all about Reduction

Wiggs

Answer 9

int sum = 0;
for (int i = 0; i < myArray.length; i++)
  sum += myArray[i];
}

Radmen

Answer 10

A bit surprised to see None of the above answers considers it can be multiple times faster using a thread pool. Here, parallel uses a fork-join thread pool and automatically break the stream in multiple parts and run them parallel and then merge. If you just remember the following line of code you can use it many places.

So the award for the fastest short and sweet code goes to -

int[] nums = {1,2,3};
int sum =  Arrays.stream(nums).parallel().reduce(0, (a,b)-> a+b);

Lets say you want to do sum of squares , then Arrays.stream(nums).parallel().map(x->x*x).reduce(0, (a,b)-> a+b). Idea is you can still perform reduce , without map .

Thera

Not necessarily fastest. Loop will outperform for small N. See my longer post with details. – Crumley

Answer 11

It depends. How many numbers are you adding? Testing many of the above suggestions:

import java.text.NumberFormat;
import java.util.Arrays;
import java.util.Locale;

public class Main {

    public static final NumberFormat FORMAT = NumberFormat.getInstance(Locale.US);

    public static long sumParallel(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array).parallel().reduce(0,(a,b)->  a + b);
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumStream(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array).reduce(0,(a,b)->  a + b);
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumLoop(int[] array) {
        final long start = System.nanoTime();
        int sum = 0;
        for (int v: array) {
            sum += v;
        }
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumArray(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array) .sum();
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumStat(int[] array) {
        final long start = System.nanoTime();
        int sum = 0;
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }


    public static void test(int[] nums) {
        System.out.println("------");
        System.out.println(FORMAT.format(nums.length) + " numbers");
        long p = sumParallel(nums);
        System.out.println("parallel " + FORMAT.format(p));
        long s = sumStream(nums);
        System.out.println("stream " +  FORMAT.format(s));
        long ar = sumArray(nums);
        System.out.println("arrays " +  FORMAT.format(ar));
        long lp = sumLoop(nums);
        System.out.println("loop " +  FORMAT.format(lp));

    }

    public static void testNumbers(int howmany) {
        int[] nums = new int[howmany];
        for (int i =0; i < nums.length;i++) {
            nums[i] = (i + 1)%100;
        }
        test(nums);
    }

    public static void main(String[] args) {
        testNumbers(3);
        testNumbers(300);
        testNumbers(3000);
        testNumbers(30000);
        testNumbers(300000);
        testNumbers(3000000);
        testNumbers(30000000);
        testNumbers(300000000);
    }
}

I found, using an 8 core, 16 G Ubuntu18 machine, the loop was fastest for smaller values and the parallel for larger. But of course it would depend on the hardware you're running:

------
3 numbers
6
parallel 4,575,234
6
stream 209,849
6
arrays 251,173
6
loop 576
------
300 numbers
14850
parallel 671,428
14850
stream 73,469
14850
arrays 71,207
14850
loop 4,958
------
3,000 numbers
148500
parallel 393,112
148500
stream 306,240
148500
arrays 335,795
148500
loop 47,804
------
30,000 numbers
1485000
parallel 794,223
1485000
stream 1,046,927
1485000
arrays 366,400
1485000
loop 459,456
------
300,000 numbers
14850000
parallel 4,715,590
14850000
stream 1,369,509
14850000
arrays 1,296,287
14850000
loop 1,327,592
------
3,000,000 numbers
148500000
parallel 3,996,803
148500000
stream 13,426,933
148500000
arrays 13,228,364
148500000
loop 1,137,424
------
30,000,000 numbers
1485000000
parallel 32,894,414
1485000000
stream 131,924,691
1485000000
arrays 131,689,921
1485000000
loop 9,607,527
------
300,000,000 numbers
1965098112
parallel 338,552,816
1965098112
stream 1,318,649,742
1965098112
arrays 1,308,043,340
1965098112
loop 98,986,436

Crumley

Answer 12

IMHO a sum function would seem a good fit to extend the Arrays class where fill, sort, search, copy, & equals live. There are a lot of handy methods hiding in the javadocs so it is a fair question when porting Fortran to java to ask before rolling our own helper method. Search through the huge javadoc index for "sum", "add" and any other keyword you might think of. You might suspect certainly someone has already done this for primitive types int, float, double, Integer, Float, Double? No matter how simple, it is always good to check. Keep the code as simple as possible and don't reinvent the wheel.

Munafo

Answer 13

I like this method personally. My code style is a little weird.

public static int sumOf(int... integers) {
    int total = 0;
    for (int i = 0; i < integers.length; total += integers[i++]);
    return total;
}

Pretty easy to use in code:

int[] numbers = { 1, 2, 3, 4, 5 };
sumOf(1);
sumOf(1, 2, 3);
sumOf(numbers);

Torero

Answer 14

I use this:

public static long sum(int[] i_arr)
{
    long sum;
    int i;
    for(sum= 0, i= i_arr.length - 1; 0 <= i; sum+= i_arr[i--]);
    return sum;
}

Interradial

C-programmer, eh? – Rapallo

Answer 15

You have to roll your own.
You start with a total of 0. Then you consider for every integer in the array, add it to a total. Then when you're out of integers, you have the sum.

If there were no integers, then the total is 0.

Rosy

Answer 16

There are two things to learn from this exercise :

You need to iterate through the elements of the array somehow - you can do this with a for loop or a while loop. You need to store the result of the summation in an accumulator. For this, you need to create a variable.

int accumulator = 0;
for(int i = 0; i < myArray.length; i++) {
    accumulator += myArray[i];
}

Simulcast

Answer 17

You can make your code look better like this:

public void someMethod(){
    List<Integer> numbers = new ArrayList<Integer>();
    numbers.addAll(db.findNumbers());
    ...
    System.out.println("Result is " + sumOfNumbers(numbers));
}

private int sumOfNumbers(List<Integer> numbers){
    int sum = 0;
    for (Integer i : numbers){
      sum += i;
    }
    return sum;
}

Lightweight

Answer 18

There is a sum() method in underscore-java library.

Code example:

import com.github.underscore.U;

public class Main {
    public static void main(String[] args) {
        int sum = U.sum(java.util.Arrays.asList(1, 2, 3, 4));

        System.out.println(sum);
        // -> 10
    }
}

Corona

Answer 19

Use below logic:

static int sum()
     {
         int sum = 0; // initialize sum
         int i;

         // Iterate through all elements summing them up
         for (i = 0; i < arr.length; i++)
            sum +=  arr[i];

         return sum;
     }

Aflcio

Answer 20

I have the right solution for your problem if you specifically have an array of type double, then this method can be used to calculate the sum of its elements. also, it using math class

import org.apache.commons.math3.stat.StatUtils;
 
public class ArraySum {
 
   public static void main(String[] args) {
    double[] array = { 10, 4, 17, 33, -2, 14 };
    int sum = (int)StatUtils.sum(array);
    System.out.println("Sum of array elements is: " + sum);
   }
}

Obtuse

Answer 21

We may use user defined function. At first initialize sum variable equal to zero. Then traverse the array and add element with sum . Then update the sum variable.

Code Snippet :

import java.util.*;   
import java.lang.*;  
import java.io.*;


class Sum
{
    public static int sum(int arr[])
    {
        int sum=0;

        for(int i=0; i<arr.length; i++)
        {
            sum += arr[i];
        }
        return sum;
    }

    public static void main (String[] args)
    {
          int arr[] = {1, 2, 3, 4, 5};

          int total = sum(arr);

          System.out.printf("%d", total);
    }
}

Shiekh

Answer 22

There is no 'method in a math class' for such thing. Its not like its a square root function or something like that.

You just need to have a variable for the sum and loop through the array adding each value you find to the sum.

Academe

Answer 23

class Addition {

     public static void main() {
          int arr[]={5,10,15,20,25,30};         //Declaration and Initialization of an Array
          int sum=0;                            //To find the sum of array elements
          for(int i:arr) {
              sum += i;
          }
          System.out.println("The sum is :"+sum);//To display the sum 
     }
} 

Ostrander

Copy of existing answer. – Celandine

Answer 24

/**
 * Sum of all elements from 1 to 1000
 */
final int sum = Stream.iterate(1, n -> n + 1).limit(1000).mapToInt(el -> el).sum();

Yb

Answer 25

Most of the answers here are using inbuilt functions-
Here is my answer if you want to know the whole logic behind this ques:

import java.util.*;

public class SumOfArray {
    public static void main(String[] args){
        Scanner inp = new Scanner(System.in);
        int n = inp.nextInt();
        int[] arr = new int[n];
        for(int i = 0; i < n; i++){
            arr[i] = inp.nextInt();
        }
        System.out.println("The sum of the array is :" + sum(arr));
    }
    static int sum(int[] arr){
        int sum = 0;
        for (int a = 0; a < arr.length; a++){
            sum = sum + arr[a];
        }
        return sum;
    }
}

Overly

Answer 26

Algorithm to find the sum of the elements of the array:

1. Initialize an array arr and a variable sum;
2. Set the value of sum=0;
3. Start a for loop from index 0 to the length of the array -1;
4. In every iteration, perform sum=sum+arr[i];
5. After the termination of the loop, print the value of the sum.

See code bellow:

import java.io*;
import java.util*;
import java.text*;
import java.math*;
import java.util.regex*;

class Test{
static int arr[] = {1,2,3,4,10,11}
//method for sum of elements in an array
static int sum()
{
int sum = 0; //initialize sum
int i;

//iterate through all elements and add them to sum
for (i=0; i<arr.length;i++)
    sum += arr[i];

 return sum;
}

//driver method
public static void main(String[] args){
System.out.println("Sum of given array is " + sum());
}


}

And if you want to get the sum of the elements of an array where the input(stdln) is initially unknown just add:

Scanner input = new Scanner(System.in);
int length = input.nextInt();

Vasos

Answer 27

 public class Num1
 {
     public static void main ()
     {
          //Declaration and Initialization
          int a[]={10,20,30,40,50}

          //To find the sum of array elements
          int sum=0;
          for(int i=0;i<a.length;i++)
          {
              sum=sum+i;
          }

          //To display the sum
          System.out.println("The sum is :"+sum);

     }
  } 

Schizogenesis

dude it's sum=sum+a[i]; – Baldhead

Answer 28

public class AddDemo {

    public static void main(String[] args) {

        ArrayList <Integer>A = new ArrayList<Integer>();

        Scanner S = new Scanner(System.in);

        System.out.println("Enter the Numbers: ");

        for(int i=0; i<5; i++){

            A.add(S.nextInt());
        }

        System.out.println("You have entered: "+A);

        int Sum = 0;

        for(int i=0; i<A.size(); i++){

            Sum = Sum + A.get(i);

        }

        System.out.println("The Sum of Entered List is: "+Sum);

    }

}

Loom

Answer 29

As of Java 8 The use of lambda expressions have become available.

See this:

int[] nums = /** Your Array **/;

Compact:

int sum = 0;
Arrays.asList(nums).stream().forEach(each -> {
    sum += each;
});

Prefer:

int sum = 0;

ArrayList<Integer> list = new ArrayList<Integer>();

for (int each : nums) { //refer back to original array
     list.add(each); //there are faster operations…
}

list.stream().forEach(each -> {
    sum += each;
});

Return or print sum.

Wildeyed

Works:int[] nums = {1,2}; final int[] sum = {0}; ArrayList<Integer> list = new ArrayList<Integer>(); for (int each : nums) { list.add(each); } list.stream().forEach(each -> { sum[0] += each; }); – Autogiro