将两个矩阵相乘的 Java 程序

2024年12月7日 | 阅读时长 10 分钟

矩阵乘法是编程中的核心概念。我们可以使用简单的嵌套 for 循环方法到高级方法在 Java 中执行矩阵乘法。嵌套 for 循环方法的时间复杂度为 O(n³)。

使用 Strassen 算法可以改进矩阵乘法的时间复杂度，其时间复杂度为 O(n^log7)。

有以下几种方法可以进行两个矩阵的乘法运算

使用 for 循环
使用 Scanner 类
使用 Java 线程
使用 Java Stream
使用 Apache Commons Math 库

如何执行矩阵乘法？

要计算两个矩阵的乘积，我们首先需要检查以下两个事实，否则矩阵乘法是不可能的。假设我们有两个矩阵 A 和 B，它们的维度分别为 m×n 和 p×q。

第一个矩阵 (A) 的列数必须等于第二个矩阵 (B) 的行数。这意味着条件 n=p 必须为真。
结果矩阵：第一个矩阵 (A) 的行数 * 第二个矩阵 (B) 的列数。因此，结果矩阵将是：m×q。

例如，3×2 和 2×4 的乘法是可能的，因为它满足上述两个条件，但 3×3 和 2×4 的乘法是不可能的。

在矩阵乘法中，第一个矩阵的一行元素与第二个矩阵的所有列通过二元运算符 (*) 相乘。

取两个要相乘的矩阵（例如 A 和 B）。
检查这两个矩阵是否兼容进行乘法运算。
创建一个新矩阵来存储两个矩阵的乘积（结果）。
遍历两个矩阵的每个元素并进行乘法运算。将此乘积存储在新矩阵的相应索引处。
打印结果矩阵。

让我们看一个简单的例子，将两个 3 行 3 列的矩阵相乘。

使用 for 循环

文件名：MatrixMultiplicationExample.java

public class MatrixMultiplicationExample{
public static void main(String args[]){
//creating two matrices  
int a[][]={{1,1,1},{2,2,2},{3,3,3}};  
int b[][]={{1,1,1},{2,2,2},{3,3,3}};  
  
//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  
}  
}}

立即测试

输出

6 6 6 
12 12 12 
18 18 18

使用 Java Scanner 类

文件名：MatrixMultiplicationScanner.java

import java.util.Scanner;
// Define a public class named MatrixMultiplicationScanner
public class MatrixMultiplicationScanner {
    // Main Method where the program starts executing
    public static void main(String[] args) {
        // Create a Scanner object to read input from the user
        Scanner scanner = new Scanner(System.in);
        // Ask the user for the Number of rows and columns of the first matrix
        System.out.println("Enter number of rows and columns for first matrix:");
        // Read the Number of rows for the first matrix
        int row1 = scanner.nextInt();
        // Read the Number of columns for the first matrix
        int col1 = scanner.nextInt();
        // Declare and initialize the first matrix with the specified size
        int[][] firstMatrix = new int[row1][col1];
        // Prompt the user to enter the elements of the first matrix
        System.out.println("Enter elements of first matrix:");
        // Nested Loop to read each element of the first matrix
        for (int i = 0; i < row1; i++) {
            for (int j = 0; j < col1; j++) {
                firstMatrix[i][j] = scanner.nextInt();
            }
        }
        // Ask the user for the Number of rows and columns of the second matrix
        System.out.println("Enter number of rows and columns for second matrix:");
        // Read the Number of rows for the second matrix
        int row2 = scanner.nextInt();
        // Read the Number of columns for the second matrix
        int col2 = scanner.nextInt();
        // Check if matrix multiplication is possible (Number of columns in the first matrix must equal the Number of rows in the second)
        if (col1 != row2) {
            System.out.println("Matrix multiplication is not possible");
            // Exit the program if multiplication is not possible
            return;
        }
        // Declare and initialize the second matrix with the specified size
        int[][] secondMatrix = new int[row2][col2];
        // Prompt the user to enter the elements of the second matrix
        System.out.println("Enter elements of second matrix:");
        // Nested Loop to read each element of the second matrix
        for (int i = 0; i < row2; i++) {
            for (int j = 0; j < col2; j++) {
                secondMatrix[i][j] = scanner.nextInt();
            }
        }
        // Call the Method to multiply the two matrices and store the result in a new matrix
        int[][] product = multiplyMatrices(firstMatrix, secondMatrix);
        // Display the resulting product matrix
        System.out.println("Product of the two matrices:");
        displayMatrix(product);
        // Close the scanner object to prevent resource leak
        scanner.close();
    }
    //Method to multiply two matrices and return the resulting matrix
    public static int[][] multiplyMatrices(int[][] firstMatrix, int[][] secondMatrix) {
        // Determine the Number of rows in the first matrix
        int r1 = firstMatrix.length;
        // Determine the Number of columns in the first matrix (assumed uniform across rows)
        int c1 = firstMatrix[0].length;
        // Determine the Number of rows in the second matrix (used in multiplication)
        int r2 = secondMatrix.length;
        // Determine the Number of columns in the second matrix
        int c2 = secondMatrix[0].length;
        // Declare and initialize the resultant product matrix
        int[][] product = new int[r1][c2];
        // Triple nested Loop to compute the product of the two matrices
        for(int i = 0; i < r1; i++) {
            for (int j = 0; j < c2; j++) {
                for (int k = 0; k < r2; k++) {
                    // Add the product of the elements to the corresponding position in the product matrix
                    product[i][j] += firstMatrix[i][k] * secondMatrix[k][j];
                }
            }
        }
        // Return the resultant product matrix
        return product;
    }
    //Method to display a matrix
    public static void displayMatrix(int[][] matrix) {
        //Loop through each row of the matrix
        for (int[] row : matrix) {
            //Loop through each column of the current row
            for (int column : row) {
                // Print each element followed by a space
                System.out.print(column + " ");
            }
            // Move to the next line after printing all columns of the current row
            System.out.println();
        }
    }
}

输出

Enter Number of rows and columns for first matrix:
3 3
Enter elements of first matrix:
1 1 1
2 2 2
3 3 3
Enter Number of rows and columns for second matrix:
3 3
Enter elements of second matrix:
1 1 1
2 2 2
3 3 3
Product of the two matrices:
6 6 6 
12 12 12 
18 18 18

使用 Java 线程

文件名：ThreadedMatrixMultiplication.java

class MatrixWorker extends Thread {
    private final int[][] matrix1; // First matrix for multiplication.
    private final int[][] matrix2; // Second matrix for multiplication.
    private final int[][] productMatrix; // Result matrix where the product is stored.
    private final int currentRow; // The row of the result matrix this thread will work on.
    // Constructor to initialize the matrices and the specific row for this thread.
    public MatrixWorker(int[][] matrix1, int[][] matrix2, int[][] productMatrix, int currentRow) {
        this.matrix1 = matrix1;
        this.matrix2 = matrix2;
        this.productMatrix = productMatrix;
        this.currentRow = currentRow;
    }
    // The run method contains the code that executes when the thread starts.
    public void run() {
        //Loop through each column of the second matrix.
        for (int col = 0; col < matrix2[0].length; col++) {
            //Loop through each element of the row from the first matrix and corresponding column from the second matrix.
            for (int k = 0; k < matrix1[0].length; k++) {
                // Calculate the product and add it to the corresponding element in the result matrix.
                productMatrix[currentRow][col] += matrix1[currentRow][k] * matrix2[k][col];
            }
        }
    }
}
// Main class that sets up the matrices and starts the multiplication threads.
public class ThreadedMatrixMultiplication {
    public static void main(String[] args) {
        // Define the matrices to be multiplied.
        int[][] firstMatrix = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
        int[][] secondMatrix = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
        // Determine the dimensions necessary for matrix multiplication.
        int rowCount = firstMatrix.length; //Number of rows in the first matrix.
        int columnCount = secondMatrix[0].length; // Number of columns in the second matrix.
        // Check if the matrices can be multiplied by comparing the dimensions.
        if (firstMatrix[0].length != secondMatrix.length) {
            System.out.println("Incompatible matrices for multiplication.");
            return; // Exit if matrices cannot be multiplied.
        }
        // Initialize the matrix that will store the result of the multiplication.
        int[][] outputMatrix = new int[rowCount][columnCount];
        // Array to hold the worker threads that perform the multiplication.
        MatrixWorker[] workers = new MatrixWorker[rowCount];
        // Print the first matrix.
        System.out.println("First Matrix:");
        printMatrix(firstMatrix);
        // Print the second matrix.
        System.out.println("Second Matrix:");
        printMatrix(secondMatrix);
        // Initialize and start a thread for each row of the result matrix.
        for (int i = 0; i < rowCount; i++) {
            workers[i] = new MatrixWorker(firstMatrix, secondMatrix, outputMatrix, i);
            workers[i].start(); // Start the thread, which invokes its run method.
        }
        // Wait for all threads to complete.
        for (MatrixWorker worker : workers) {
            try {
                worker.join(); // Wait for this thread to die.
            } catch (InterruptedException e) {
                System.out.println("Thread interrupted: " + e.getMessage());
            }
        }
        // Print the resultant matrix after all threads have finished their computation.
        System.out.println("Resultant Matrix:");
        printMatrix(outputMatrix);
    }
    // Utility method to print a matrix.
    private static void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int value : row) {
                System.out.print(value + " "); // Print each element of the row.
            }
            System.out.println(); // Move to the next line after printing all columns in the row.
        }
    }
}

输出

First Matrix:
1 1 1 
2 2 2 
3 3 3 
Second Matrix:
1 1 1 
2 2 2 
3 3 3 
Resultant Matrix:
6 6 6 
12 12 12 
18 18 18

使用 Java Stream

文件名：MatrixMultiplication.java

import java.util.Arrays;
import java.util.stream.IntStream;
public class MatrixMultiplication {
    public static void main(String[] args) {
        // Initialize two matrices for multiplication.
        int[][] matrixA = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
        int[][] matrixB = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
        // Print Matrix A
        System.out.println("Matrix A:");
        printMatrix(matrixA);
        // Print Matrix B
        System.out.println("Matrix B:");
        printMatrix(matrixB);
        // Call the multiplyMatrices method to calculate the product of matrixA and matrixB.
        int[][] productMatrix = multiplyMatrices(matrixA, matrixB);
        // Print the result of the matrix multiplication.
        System.out.println("Product Matrix:");
        printMatrix(productMatrix);
    }
    //Method to print a matrix.
    private static void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            System.out.println(Arrays.toString(row)); // Arrays.toString is used to print each row of the matrix.
        }
    }
    //Method to multiply two matrices using Java Streams API.
    public static int[][] multiplyMatrices(int[][] matrixA, int[][] matrixB) {
        // Get the Number of rows in matrixA.
        int rowMatrixA = matrixA.length;
        // Get the Number of columns in matrixA (assuming uniform row length).
        int colMatrixA = matrixA[0].length;
        // Get the Number of columns in matrixB.
        int colMatrixB = matrixB[0].length;
        // Use streams to iterate over rows of the resultant matrix.
        return IntStream.range(0, rowMatrixA)
            .mapToObj(row -> 
                // For each row, iterate over columns of the resultant matrix.
                IntStream.range(0, colMatrixB)
                    .map(col ->
                        // Calculate each element of the product matrix as the sum of products of corresponding elements.
                        IntStream.range(0, colMatrixA)
                            .map(index -> matrixA[row][index] * matrixB[index][col]) // Multiply the elements.
                            .sum()) // Sum the products to get the element of the product matrix.
                    .toArray()) // Convert the stream of elements into an array representing a row of the product matrix.
            .toArray(int[][]::new); // Convert the stream of rows into a two-dimensional array representing the product matrix.
    }
}

输出

Matrix A:
[1, 1, 1]
[2, 2, 2]
[3, 3, 3]
Matrix B:
[1, 1, 1]
[2, 2, 2]
[3, 3, 3]
Product Matrix:
[6, 6, 6]
[12, 12, 12]
[18, 18, 18]

使用 Apache Commons Math 库

文件名：MultiplyMatricesUsingApache.java

import org.apache.commons.math3.linear.MatrixUtils;
import org.apache.commons.math3.linear.RealMatrix;
public class MultiplyMatricesUsingApache {
    public static void main(String[] args) {
        // Initialize the data for two matrices as arrays of doubles.
        double[][] dataMatrixA = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
        double[][] dataMatrixB = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
        // Convert the double arrays to RealMatrix instances for matrix operations.
        RealMatrix matrixA = MatrixUtils.createRealMatrix(dataMatrixA);
        RealMatrix matrixB = MatrixUtils.createRealMatrix(dataMatrixB);
        // Print the first matrix to the console.
        System.out.println("Matrix A:");
        printMatrix(matrixA.getData()); // Call the printMatrix method to display matrixA.
        // Print the second matrix to the console.
        System.out.println("Matrix B:");
        printMatrix(matrixB.getData()); // Call the printMatrix method to display matrixB.
        // Perform matrix multiplication of matrixA and matrixB.
        RealMatrix matrixProduct = matrixA.multiply(matrixB);
        // Display the result of the multiplication.
        System.out.println("Matrix Product:");
        printMatrix(matrixProduct.getData()); // Call the printMatrix method to display the product matrix.
    }
    // A helper method to print the contents of a matrix.
    private static void printMatrix(double[][] matrix) {
        // Iterate through each row of the matrix.
        for (double[] row : matrix) {
            // Iterate through each element of the row and print it, followed by a space.
            for (double value : row) {
                System.out.print(value + " ");
            }
            // Move to the next line after printing all elements of the row.
            System.out.println();
        }
    }
}

输出

Matrix A:
1.0 1.0 1.0 
2.0 2.0 2.0 
3.0 3.0 3.0 
Matrix B:
1.0 1.0 1.0 
2.0 2.0 2.0 
3.0 3.0 3.0 
Matrix Product:
6.0 6.0 6.0 
12.0 12.0 12.0 
18.0 18.0 18.0

Java 程序：两个矩阵相乘的选择题

1. 标准矩阵乘法算法的时间复杂度是多少？

O(n)
O(n^2)
O(n³)
O(log n)

答案：C

解释：标准矩阵乘法算法的时间复杂度为 O(n^3)，其中 'n' 是矩阵的行数或列数。

2. 以下哪项陈述最能描述高效地相乘两个矩阵的方法？

遍历矩阵的每个元素并执行乘法。
分而治之法。
使用动态规划优化乘法。
Strassen 算法。

答案：D

解释：Strassen 算法是一种高效的分而治之算法，用于矩阵乘法。

3. 将一个 m x n 大小的矩阵与另一个 p x q 大小的矩阵相乘时，结果矩阵的维度将是多少？

m x p
n x q
m x q
p x n

答案：A

解释：矩阵相乘时，结果矩阵的维度将等于第一个矩阵的行数乘以第二个矩阵的列数。

4. 以下哪种 Java 数据结构通常用于表示矩阵？

ArrayList
LinkedList
Array
Stack

答案：C

解释：二维数组通常用于在 Java 中表示矩阵。

5. 考虑以下代码片段

 
int[][] matrix1 = {{1, 2}, {3, 4}};
int[][] matrix2 = {{5, 6}, {7, 8}};
int[][] result = multiplyMatrices(matrix1, matrix2);

结果矩阵的维度将是多少？

2 x 2
2 x 3
3 x 2
3 x 3

答案：A

解释：两个 2x2 矩阵相乘的结果矩阵的维度将是 2x2。

下一个主题Java 程序

将两个矩阵相乘的 Java 程序

如何执行矩阵乘法？

使用 for 循环

使用 Java Scanner 类

使用 Java 线程

使用 Java Stream

使用 Apache Commons Math 库

Java 程序：两个矩阵相乘的选择题

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java 程序

将两个矩阵相乘的 Java 程序

如何执行矩阵乘法？

使用 for 循环

使用 Java Scanner 类

使用 Java 线程

使用 Java Stream

使用 Apache Commons Math 库

Java 程序：两个矩阵相乘的选择题

相关帖子

查找字符串中重复字符的 Java 程序

Krishnamurthy Number Java

如何在 Java 中将字符串转换为布尔值

ATM program Java

将字符串分成 'N' 等份的 Java 程序

How to Compare Two Objects in Java

打印数组中的奇数和偶数的 Java 程序

Spy Number in Java

Java Program to Display Odd Numbers From 1 to 100

在控制台上打印以下图案的 Java 程序 5

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器