Find the Sum of All Elements in a 2D Array in Java

Introduction

Finding the sum of all elements in a 2D array is one of the most common matrix operations in Java. Since a 2D array is an array of arrays, you need to visit every row and every column to calculate the overall total.

If you're already familiar with summing elements in a one-dimensional array, the concept is almost identical—simply add one more loop to iterate through each row. In this tutorial, you'll learn multiple approaches to calculate the sum of all elements in a 2D array, including nested loops and Java Streams, along with best practices, common mistakes, and performance considerations.

Problem Statement

Given the following 2D array:

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

Calculate the sum of all elements:

1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 = 45

Method 1: Using Nested Loops (Recommended)

The most common and beginner-friendly approach is to use nested loops.

• The outer loop iterates through each row.
• The inner loop iterates through each element in that row.
• Every element is added to a running total.

Java Program

public class Main {

    public static void main(String[] args) {

        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        int totalSum = 0;

        for (int row = 0; row < matrix.length; row++) {

            for (int col = 0; col < matrix[row].length; col++) {

                totalSum += matrix[row][col];
            }
        }

        System.out.println("Total Sum = " + totalSum);
    }
}

Output

Total Sum = 45

Time Complexity

O(rows × columns)

Space Complexity

O(1)

Method 2: Using Enhanced For Loop

The enhanced for loop makes the code shorter and easier to read.

Java Program

public class Main {

    public static void main(String[] args) {

        int[][] matrix = {
            {1,2,3},
            {4,5,6},
            {7,8,9}
        };

        int sum = 0;

        for (int[] row : matrix) {

            for (int value : row) {

                sum += value;
            }
        }

        System.out.println("Total Sum = " + sum);
    }
}

Output

Total Sum = 45

This approach is ideal when you only need to read values and don't require element indexes.

Method 3: Using Java Streams

Java 8 introduced Streams, providing a concise functional approach.

Java Program

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        int[][] matrix = {
            {1,2,3},
            {4,5,6},
            {7,8,9}
        };

        int totalSum = Arrays.stream(matrix)
                             .flatMapToInt(Arrays::stream)
                             .sum();

        System.out.println("Total Sum = " + totalSum);
    }
}

Output

Total Sum = 45

How It Works

• Arrays.stream(matrix) creates a stream of rows (int[]).
• flatMapToInt(Arrays::stream) converts every row into a single stream of integers.
• sum() calculates the total of all values.

This approach is concise and works well when you're already using the Stream API.

Handling Jagged Arrays

A jagged array contains rows of different lengths.

Fortunately, the nested loop solution works without any modification because it uses:

matrix[row].length

instead of a fixed column count.

Java Program

public class Main {

    public static void main(String[] args) {

        int[][] jagged = {
            {1,2},
            {3,4,5},
            {6}
        };

        int total = 0;

        for (int row = 0; row < jagged.length; row++) {

            for (int col = 0; col < jagged[row].length; col++) {

                total += jagged[row][col];
            }
        }

        System.out.println(total);
    }
}

Output

21

The Streams approach also handles jagged arrays correctly because it processes each row independently.

Step-by-Step Explanation

Consider this code:

int totalSum = 0;

for (int row = 0; row < matrix.length; row++) {

    for (int col = 0; col < matrix[row].length; col++) {

        totalSum += matrix[row][col];
    }
}

Here's what happens:

1. Initialize totalSum to 0.
2. The outer loop selects the first row.
3. The inner loop visits every element in that row.
4. Each value is added to totalSum.
5. The process repeats for every remaining row.
6. After all rows are processed, totalSum contains the final answer.

Internal Working

For the following matrix:

{
    {1,2,3},
    {4,5,6},
    {7,8,9}
}

The accumulation happens like this:

Start = 0

1  → 1
2  → 3
3  → 6

4  → 10
5  → 15
6  → 21

7  → 28
8  → 36
9  → 45

Final Sum = 45

Each element contributes to the running total until every value has been processed.

Real-Life Analogy

Imagine calculating the total marks of students stored in a classroom seating chart.

You begin with the first row, adding each student's marks. Once that row is complete, you move to the next row and continue until every student's marks have been included.

The final total represents the sum of all marks in the classroom.

Best Practices

• Use matrix[row].length instead of hardcoding the number of columns.
• Initialize the accumulator (sum) to zero before starting the loops.
• Use enhanced for loops when indexes aren't required.
• Use Java Streams for concise code in stream-based applications.
• Use long instead of int if the matrix contains very large numbers.
• Consider moving the summation logic into a reusable utility method if used frequently.

Common Mistakes

Hardcoding the Column Count

Incorrect:

for (int col = 0; col < 3; col++)

Correct:

for (int col = 0; col < matrix[row].length; col++)

Forgetting to Initialize the Sum

Incorrect:

int sum;

Correct:

int sum = 0;

Confusing Total Sum with Row Sum

The following code calculates only one row's sum:

int rowSum = 0;

To calculate the total matrix sum, use a single accumulator outside both loops.

Ignoring Integer Overflow

For very large matrices:

long total = 0;

Using long prevents integer overflow.

Expert Tips

• The same nested-loop technique can be used to calculate averages, maximum values, minimum values, and element counts.
• The Stream API makes many aggregate operations concise, such as:

Arrays.stream(matrix)
      .flatMapToInt(Arrays::stream)
      .max();

• The same concept extends naturally to 3D arrays by adding another nested loop.
• Enhanced for loops improve readability whenever indexes are unnecessary.
• Nested loops generally remain the preferred approach in interviews because they clearly demonstrate your understanding of array traversal.

Comparison of Approaches

Frequently Asked Questions

What is the easiest way to find the sum of a 2D array?

Using nested loops is the simplest and most widely used approach.

Does this work for jagged arrays?

Yes. As long as you use matrix[row].length, it works correctly for rows of different lengths.

What does flatMapToInt() do?

It converts multiple rows into one continuous stream of integers so they can be processed together.

Should I use int or long?

Use int for normal arrays. Use long if the total sum could exceed the maximum value of an integer.

Can I use enhanced for loops?

Yes. Enhanced for loops make the code shorter and are ideal when indexes aren't needed.

Is the Streams approach faster?

Performance is generally similar for typical applications. Nested loops may be slightly faster, while Streams offer cleaner and more expressive code.

What happens if the 2D array is empty?

The loops execute zero times, so the sum remains 0.

Can this approach be extended to 3D arrays?

Yes. Simply add another nested loop (or another level of stream flattening) to traverse the additional dimension.