# Multiply Two Matrices in Java

(Last Updated On: 07/09/2023)

In this blog, we’ll dive into the concept of matrix multiplication in Java programming.

Matrix multiplication is a fundamental operation in various fields of science, engineering, and computer science. Whether you’re working on data analysis, computer graphics, or scientific computing, understanding how to multiply two matrices is a valuable skill.

## What are 2D arrays in Java?

Before we understand the concept of matrix multiplication in Java, let’s revise some programming basics. Java is an object-oriented, high-level programming language known for its portability and readability. To work with matrices, we’ll make use of arrays, including multi-dimensional arrays, also known as 2D arrays.

In Java, you can define a 2D array as follows:

```// Initialize a 2x2 matrix
int[][] matrix = {{a, b}, {c, d}};```

## How to multiply two matrices in Java?

Our main objectives are twofold: first, to teach you how to multiply two matrices in Java using nested loops, and then second, to make this multiplication applicable to matrices of any size. By the end of this tutorial, you will have the knowledge to effectively tackle matrix multiplication tasks in your Java projects.

## Using nested loops

```// Multiply Two Matrices in Java
public class MatrixMultiplicationEx{
public static void main(String args[]){
//creating two matrices
int a[][]={{0,4,8},{1,2,6},{4,9,6}};
int b[][]={{7,9,5},{3,4,2},{7,3,5}};
//creating another matrix to store the multiplication of two matrices
int c[][]=new int[3][3];  //3 rows and 3 columns
//multiplying and printing multiplication of 2 matrices
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
c[i][j]=0;
for(int k=0;k<3;k++)
{
c[i][j]+=a[i][k]*b[k][j];
}//end of k loop
System.out.print(c[i][j]+" ");  //printing matrix element
}//end of j loop
System.out.println();//new line
}
}
} ```

Learn How to Add Two Matrices in Java, Here!

Explanation of the code:

1. The program starts by defining a Java class named `MatrixMultiplicationEx`.

2. The ‘main’ method creates two matrices ‘a’ and ‘b’ inside it. Initialize these matrices with integer values.

3. They create another matrix ‘c’ to store the result of the matrix multiplication. It’s initialized as a 3×3 matrix (3 rows and 3 columns) because both `a` and `b` are 3×3 matrices.

4. The nested `for` loops are used to iterate through the rows and columns of matrix `c`. The outer loop iterates over the rows (`i`), and the inner loop iterates over the columns (`j`) of `c`.

5. Inside the innermost loop (controlled by variable `k`), matrix multiplication is performed. The value of `c[i][j]` is calculated by summing the products of corresponding elements from matrices `a` and `b`.

6. After the innermost loop finishes, the result of the multiplication is printed with `System.out.print`. Moreover, the space between numbers is used to separate the elements in the same row.

7. After printing the elements of one row of matrix `c`, `System.out.println()` is used to move to the next line to print the elements of the next row.

8. The loops compute and print all elements of matrix ‘c’ until they are complete.

9. The program completes once the loops finish, and it displays the result of the matrix multiplication in the console.

#### Output:

``````68 40 48
55 35 39
97 90 68``````

Check out Javascript for Loop, Now!

## Multiply Matrix of Any Size

The below code demonstrates how to multiply two matrices in Java using nested loops and provides a clear explanation of each step in the process:

```// Multiply Two Matrices in Java
import java.io.*;
class MultiplyMatrixEx {
static void printMatrix(int M[][],
int rowSize,
int colSize)
{
for (int i = 0; i < rowSize; i++) {
for (int j = 0; j < colSize; j++)
System.out.print(M[i][j] + " ");

System.out.println();
}
}
static void multiplyMatrix(
int r1, int c1, int A[][],
int r2, int c2, int B[][])
{
int i, j, k;
// Print the matrices A and B
System.out.println("\nMatrix A:");
printMatrix(A, r1, c1);
System.out.println("\nMatrix B:");
printMatrix(B, r2, c2);
// Check if multiplication is Possible
if (r2 != c1) {

System.out.println(
"\nMultiplication Not Possible");
return;
}
int C[][] = new int[r1][c2];

// Multiply the two matrices
for (i = 0; i < r1; i++) {
for (j = 0; j < c2; j++) {
for (k = 0; k < r2; k++)
C[i][j] += A[i][k] * B[k][j];
}
}
// Print the result
System.out.println("\nResultant Matrix:");
printMatrix(C, r1, c2);
}
// Driver code
public static void main(String[] args)
{

int r1 = 3, c1 = 3, r2 = 3, c2 = 3;
int A[][] = { { 5, 4, 9 },
{ 6, 2, 8 },
{ 4, 9, 1 } };

int B[][] = { { 8, 6, 4 },
{ 8, 1, 5 },
{ 9, 3, 1 } };

multiplyMatrix(r1, c1, A,
r2, c2, B);
}
}```

Explanation of code:

1. The code begins by defining a class named `MultiplyMatrixEx`.

2. The ‘printMatrix’ function prints the content of a given matrix. In addition it takes the matrix `M`, its number of rows `rowSize`, and its number of columns `colSize` as parameters and iterates through the matrix to print its elements row by row.

3. The `multiplyMatrix` function implements the matrix multiplication logic. It takes the dimensions (`r1`, `c1`) and the content of the first matrix `A`, as well as the dimensions (`r2`, `c2`) and the content of the second matrix `B`.

4. It first prints the matrices `A` and `B` using the `printMatrix` function to show the input matrices to the user.

5. The code checks if matrix multiplication is possible by comparing the number of columns in the first matrix (`c1`) with the number of rows in the second matrix (`r2`). Multiplication is not possible if they are not equal; however, it displays an error message.

6. If multiplication is possible, a result matrix `C` is initialized with dimensions (`r1`, `c2`), where `r1` is the number of rows of the first matrix, and `c2` is the number of columns of the second matrix.

7. We use nested loops to perform matrix multiplication. The code iterates through each element of the result matrix `C` and calculates its value by multiplying and accumulating elements from matrices `A` and `B`.

8. Finally, the code prints the resultant matrix `C` using the `printMatrix` function to display the product of the two input matrices.

9. The ‘main’ function defines sample matrices ‘A’ and ‘B’ with their dimensions and then calls the ‘multiplyMatrix’ function to perform the matrix multiplication and display the result.

Get a Complete list of Online Certification Courses in India here!

#### Output:

``````Matrix A:
5 4 9
6 2 8
4 9 1

Matrix B:
8 6 4
8 1 5
9 3 1

Resultant Matrix:
153 61 49
136 62 42
113 36 62``````

In conclusion, this article has provided a clear and comprehensive guide on matrix multiplication in Java. It has covered the fundamental concepts, demonstrated how to perform matrix multiplication using nested loops, and emphasized the versatility of this approach for matrices of any size. Armed with this knowledge, readers can confidently apply matrix multiplication techniques in various Java projects.

We hope this blog post has been helpful in understanding ‘Multiply Two Matrices in Java’. For more information on Java programming, please visit our Newtum website. We offer a variety of courses and blogs that can help you learn Java and other programming languages from beginner to advanced levels. Happy coding!

## FAQ

1. How to define matrices in Java for matrix multiplication?

Answer: To define matrices in Java, you can use 2D arrays. For example:

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

2. Can I multiply matrices of different sizes in Java?

Answer: No, you cannot multiply matrices of different sizes in Java. Furthermore, matrix multiplication requires that the number of columns in the first matrix equals the number of rows in the second matrix.

3. What is the time complexity of matrix multiplication in Java using nested loops?

Answer: The time complexity of matrix multiplication using nested loops is O(n^3), where ‘n’ is the number of rows or columns in the square matrices being multiplied.

4. Is there a built-in function for matrix multiplication in Java?

Answer: Java does not provide a built-in function for matrix multiplication. However, you need to implement matrix multiplication using loops or use third-party libraries like Apache Commons Math.

5. How can I optimize matrix multiplication for large matrices in Java?

Answer: For large matrices, consider using parallel processing techniques or libraries that provide optimized matrix multiplication algorithms to improve performance.