Calculating the sum of all numbers in an array in Java

java

stream-engineering

performance

best-practices

byAlex Kataev·Oct 19, 2024

Benefit from the power of streams in Java to concisely calculate the sum of an array:

// array of integers
int[] array = {1, 2, 3, 4, 5};
// stream magic coming through
int sum = Arrays.stream(array).sum();
System.out.println("Sum: " + sum); // Prints "Sum: 15" but you knew that, right?

Squeeze the power of Arrays.stream(array).sum() for a direct and elegant solution.

Streamlining the process with Java 8

Time to get fancy with Java 8. Instead of traditional for-loops, use IntStream to embrace a stream-based approach. It's not only succinct but also quite elegant.

Subarray sums: Targeting a range

For identifying the sum of a specific portion of the array:

// Specifying the target range (0-2)
int sumSubarray = Arrays.stream(array, 0, 3).sum();

Double, double, toil and trouble: handling non-integer arrays

Java 8 is ready for some fun with double and long types:

// Floating points can join the party too
double[] doubleArray = {1.5, 2.5, 3.5};
double sumDoubles = Arrays.stream(doubleArray).sum();

A number by any other name: processing string numbers

Converting and summing up a string of numbers:

// Your numbers read like a poem? No problem!
String numbers = "1 2 3 4 5";
int sumStrings = Arrays.stream(numbers.split("\\s+")).mapToInt(Integer::parseInt).sum();

Traditional approach: Looping for those non-streamers

Dive into the less glamorous but essential for-loop implementations.

Classic for-loop

// Old school but cool
int loopSum = 0;
for (int number : array) {
    loopSum += number;
}

Method to the madness: Grouping logic in methods

For simplifying reuse and improving clarity, wrap up sum logic in a function:

// Wrapped as a gift 
public static int calculateSum(int[] array) {
    int sum = 0;
    for (int num : array) {
        sum += num;
    }
    return sum; // The sweet reveal
}

Meet new friends: Leveraging external libraries

The world outside core Java offers great methods like from Apache Commons Math:

// Taking the liberty of external libraries
double[] doubleArray = {1.0, 2.0, 3.0};
double sum = StatUtils.sum(doubleArray);

Performance analysis: Streams vs. loops

For small arrays or performance-critical implementations, a tuned for-loop may outrun streams. However, with larger arrays, streams' capability to be parallelized is a big win.