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

*Learn Spring*course:

**>> CHECK OUT THE COURSE**

Last modified: May 15, 2021

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.

Follow the Java Category

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