Find Sum and Average in a Java Array

1. Introduction

In this quick tutorial, we’ll cover how to calculate the sum and average of the elements in an array using both Java standard loops and the Stream API. For simplicity, we’ll ignore the cases where the input array is null or empty.

2. Find Sum of Array Elements

2.1. Sum Using a for Loop

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

Next, let’s implement this logic by initializing the sum variable with 0 and adding each item of the array as we go:

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

2.2. Sum With the Java Stream API

Alternatively, we can use the Stream API to achieve 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.

However, if we want to use a stream with 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();
}

3. Find the Average of a Java Array

3.1. Average Without the Stream API

Once we know how to calculate the sum of array elements, finding the 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;
}

It’s important to note that:

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

3.2. Average Using the Java Stream API

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

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

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

4. An Example: Calculating the Sum and Average of Positive Numbers Only

We’ve discussed different ways to calculate the sum and average of a Java array. Next, let’s use these techniques to solve a practical problem.

Let’s say we have an int[] array:

static final int[] MY_ARRAY = new int[] { 1, -2, 3, -4, 5, -6, 7, 42, 0 };

As we can see, MY_ARRAY contains a zero as well as both positive and negative numbers. Now, we aim to calculate the sum and average of positive numbers only:

static final int EXPECTED_SUM = 58; //1+3+5+7+42
static final double EXPECTED_AVG = 11.60D; //(1+3+5+7+42)/5

Next, let’s see how to solve the problem by extending the approaches we learned.

For simplicity, we’ll leverage unit test assertions to verify if the result is correct.

4.1. Using a for Loop

We can add a positive check to the for-loop approach to solve this problem. Next, let’s have a look at the implementation:

int count = 0;
int sum = 0;
for (int value : MY_ARRAY) {
    if (value > 0) {
        count++;
        sum += value;
    }
}
double avg = (double) sum / count;

assertEquals(EXPECTED_SUM, sum);
assertEquals(EXPECTED_AVG, avg);

In this example, we check if the current number is positive (n > 0) during the iteration to ensure only positive elements join the sum and average calculation.

4.2. Using the Stream API

Similarly, we can solve the problem using the Stream API. A straightforward idea is to filter out zeros and negative numbers from the IntStream object and call the sum() or average() methods to get the final result.

Next, let’s see how this is done:

int sum = Arrays.stream(MY_ARRAY).filter(n -> n > 0).sum();
double avg = Arrays.stream(MY_ARRAY).filter(n -> n > 0)
  .average()
  .orElse(Double.NaN);

assertEquals(EXPECTED_SUM, sum);
assertEquals(EXPECTED_AVG, avg);

As the code shows, we added a filter() call to the Stream pipeline to calculate sum() and average() only on positive numbers.

5. How to Calculate the Average of a 2D Array in Java

Calculating the average of a 2D array follows a similar logic as that of a 1D array. We need to sum up all the elements and then divide by the total number of elements.

5.1. Average Without the Stream API

First, we can calculate the average using nested loops:

public static double findAverageWithoutUsingStream(int[][] array) {
    int sum = 0;
    int count = 0;
    for (int[] row : array) {
        for (int value : row) {
            sum += value;
            count++;
        }
    }
    return (double) sum / count;
}

The findAverageWithoutUsingStream() method determines the average of a 2D array using two nested loops. Initially, two variables, sum and count, are set to zero. The outer loop iterates through each array row, and the inner loop goes through each element within these rows. Each element’s value is added to sum, and count is incremented accordingly.

Once all elements have been processed, the average is obtained by dividing sum by count. Casting sum to double ensures precise division and results in a double value.

5.2. Average Using the Java Stream API

Alternatively, we can use the Stream API to calculate the average:

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

The findAverageUsingStream() method calculates the average of a 2D array using the Stream API. This process starts by converting the 2D array into a stream of 1D arrays with Arrays.stream(array).

The stream of 1D arrays is then flattened into a single IntStream using flatMapToInt(Arrays::stream). This IntStream contains all the elements of the 2D array in a single stream. The average is then calculated using the average() method of the IntStream, which returns an OptionalDouble.

6. Conclusion

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