Multiply Two Matrices in Java (Full Guide With Dimension Rules)

Introduction

Matrix multiplication is one of the most important operations in linear algebra and has applications in computer graphics, machine learning, scientific computing, game development, and data analysis. Unlike addition or subtraction, matrix multiplication is not performed element by element.

Instead, each element of the resulting matrix is calculated using the dot product of a row from the first matrix and a column from the second matrix. Because of this, matrix multiplication requires three nested loops, making it more complex than most other 2D array operations.

In this tutorial, you'll learn the matrix multiplication rules, implement the algorithm in Java, understand the dot-product concept, and avoid common mistakes.

Problem Statement

Given two matrices:

Matrix A (2 × 3)

1 2 3
4 5 6

Matrix B (3 × 2)

7  8
9 10
11 12

Find the product:

A × B

The expected result is:

58   64
139 154

Matrix Multiplication Rule

Before multiplying two matrices, their dimensions must satisfy one important condition.

If:

Matrix A = m × n

Matrix B = n × p

then multiplication is valid only when:

Columns of A == Rows of B

The resulting matrix will have dimensions:

m × p

Example

Valid:

2 × 3

×

3 × 4

=

2 × 4

Invalid:

2 × 3

×

2 × 4

The multiplication cannot be performed because:

3 ≠ 2

Method: Using Triple Nested Loops

The standard algorithm uses three nested loops.

• The outer loop selects a row from Matrix A.
• The middle loop selects a column from Matrix B.
• The inner loop calculates the dot product.

Java Program

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

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

        int[][] b = {
            {7,8},
            {9,10},
            {11,12}
        };

        int rowsA = a.length;
        int colsA = a[0].length;

        int rowsB = b.length;
        int colsB = b[0].length;

        if (colsA != rowsB) {

            System.out.println("Matrix multiplication is not possible.");

            return;
        }

        int[][] result = new int[rowsA][colsB];

        for (int row = 0; row < rowsA; row++) {

            for (int col = 0; col < colsB; col++) {

                int sum = 0;

                for (int k = 0; k < colsA; k++) {

                    sum += a[row][k] * b[k][col];
                }

                result[row][col] = sum;
            }
        }

        for (int[] row : result) {

            System.out.println(Arrays.toString(row));
        }
    }
}

Output

[58, 64]
[139, 154]

Time Complexity

O(rowsA × colsA × colsB)

For square matrices, this becomes:

O(n³)

Space Complexity

O(rowsA × colsB)

Understanding the Dot Product

Every element in the result matrix is obtained by multiplying corresponding elements from:

• One row of Matrix A
• One column of Matrix B

and then adding the products.

For example:

Result[0][0]

uses:

Row 0 of Matrix A

1 2 3

and

Column 0 of Matrix B

7
9
11

Calculation:

(1 × 7)

+

(2 × 9)

+

(3 × 11)

=

7 + 18 + 33

=

58

The same process is repeated for every cell in the result matrix.

Step-by-Step Explanation

Consider this loop structure:

for (int row = 0; row < rowsA; row++) {

    for (int col = 0; col < colsB; col++) {

        int sum = 0;

        for (int k = 0; k < colsA; k++) {

            sum += a[row][k] * b[k][col];
        }

        result[row][col] = sum;
    }
}

Here's what happens:

1. Select one row from Matrix A.
2. Select one column from Matrix B.
3. Multiply corresponding elements.
4. Add the products together.
5. Store the final value in the result matrix.
6. Repeat for every row and every column.

Internal Working

To calculate:

result[0][0]

Java performs:

1 × 7 = 7

2 × 9 = 18

3 × 11 = 33

Total = 58

To calculate:

result[0][1]

Java performs:

1 × 8 = 8

2 × 10 = 20

3 × 12 = 36

Total = 64

The same logic continues until every element of the result matrix has been computed.

Real-Life Analogy

Imagine a restaurant.

Matrix A represents the quantity of ingredients required for each recipe.

Matrix B represents the cost of every ingredient.

To calculate the total cost of preparing a recipe, you multiply the quantity of each ingredient by its price and then add all the costs together.

This is exactly what the dot product does during matrix multiplication.

Best Practices

• Always verify that the number of columns in Matrix A equals the number of rows in Matrix B.
• Create the result matrix using the dimensions rowsA × colsB.
• Use meaningful variable names such as row, col, and k.
• Validate matrix dimensions before performing multiplication.
• Extract the multiplication logic into a reusable method if it is used frequently.
• For very large matrices, consider optimized libraries instead of implementing the algorithm manually.

Common Mistakes

Ignoring the Dimension Rule

Incorrect:

2 × 3

×

2 × 4

This multiplication is invalid.

Always verify:

colsA == rowsB

Creating the Result Matrix with the Wrong Size

Incorrect:

new int[rowsA][colsA]

Correct:

new int[rowsA][colsB]

Mixing Up Loop Variables

Remember:

• row → rows of Matrix A
• col → columns of Matrix B
• k → shared dimension

Using the wrong indexes produces incorrect results.

Assuming Matrix Multiplication Is Commutative

Incorrect assumption:

A × B

=

B × A

In general:

A × B

≠

B × A

The results are usually different, and sometimes one multiplication isn't even valid.

Expert Tips

• The standard matrix multiplication algorithm uses three nested loops, making it one of the most common examples of O(n³) complexity.
• Matrix multiplication is associative but not commutative.
• Matrix multiplication is widely used in graphics transformations, machine learning, neural networks, robotics, cryptography, and scientific simulations.
• For large-scale applications, optimized algorithms such as Strassen's Algorithm or specialized numerical libraries can significantly improve performance.

Comparison of Matrix Operations

Frequently Asked Questions

What is the rule for matrix multiplication?

The number of columns in the first matrix must equal the number of rows in the second matrix.

Why are three loops required?

The first two loops select the position in the result matrix, while the third loop calculates the dot product needed for that position.

Is matrix multiplication commutative?

No.

In general:

A × B ≠ B × A

What is the time complexity?

The standard algorithm runs in:

O(n³)

for multiplying two square matrices.

What happens if the dimensions don't match?

Matrix multiplication is undefined. Your program should detect this and stop instead of attempting the operation.

Can I multiply a matrix by itself?

Yes, provided the matrix is square (or more generally, the number of its columns equals the number of its rows).

Are there faster algorithms?

Yes. Algorithms such as Strassen's Algorithm reduce the asymptotic time complexity for very large matrices, although the standard triple-loop approach is sufficient for most applications.

Where is matrix multiplication used?

Matrix multiplication is used extensively in linear algebra, computer graphics, machine learning, image processing, scientific computing, robotics, game development, and data analysis.