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

*Learn Spring*course:

**>> CHECK OUT THE COURSE**

Last modified: August 6, 2020

In this quick tutorial, we'll cover how we can calculate sum & average in an array using both Java standard loops and the *Stream* API.

In order to find the sum of all elements in an array, **we can simply iterate the array and add each element to a sum accumulating variable.**

This very simply starts with a *sum* of 0 and add each item in the array as we go:

```
public static int findSumWithoutUsingStream(int[] array) {
int sum = 0;
for (int value : array) {
sum += value;
}
return sum;
}
```

**We can use the Stream API for achieving the same result:**

```
public static int findSumUsingStream(int[] array) {
return Arrays.stream(array).sum();
}
```

It's important to know that the *sum() *method only supports primitive type streams.

If we want to use a stream on a boxed *Integer* value, we must first convert the stream into *IntStream *using the *mapToInt *method.

After that, we can apply the *sum() *method to our newly converted *IntStream*:

```
public static int findSumUsingStream(Integer[] array) {
return Arrays.stream(array)
.mapToInt(Integer::intValue)
.sum();
}
```

You can read a lot more about the Stream API here.

Once we know how to calculate the sum of array elements, finding average is pretty easy – as *Average = Sum of Elements / Number of Elements*:

```
public static double findAverageWithoutUsingStream(int[] array) {
int sum = findSumWithoutUsingStream(array);
return (double) sum / array.length;
}
```

*Notes*:

- Dividing an
*int*by another*int*returns an*int*result.**To get an accurate average, we first cast***sum*to*double*. - Java
*Array*has a*length*field which stores the number of elements in the array.

```
public static double findAverageUsingStream(int[] array) {
return Arrays.stream(array).average().orElse(Double.NaN);
}
```

*IntStream.average()* returns an *OptionalDouble* which may not contain a value and which needs a special handling.

Read more about *Optionals* in this article and about the *OptionalDouble *class in the Java 8 Documentation.

In this article, we explored how to find sum/average of *int* array elements.

As always, the code is available over on Github.