Java 实战指南：如何优雅地实现任意大小矩阵的乘法

2026-02-15 14:44:20 0条评论 1次阅读 0人点赞

在计算机科学和数学领域，矩阵乘法是一个非常基础但又极其重要的操作。与两个简单的数字相乘不同，矩阵乘法涉及到多维数据的处理，逻辑相对复杂，特别是在处理任意大小的矩阵时，我们需要考虑维度的兼容性以及循环嵌套的效率。

在这篇文章中，我们将一起深入探讨如何在 Java 中实现两个任意大小矩阵的乘法。我们不仅会学习基础的实现方法，还会深入分析背后的算法逻辑、时间复杂度，以及在实际开发中如何优化这段代码。无论你是在做图像处理、3D 游戏开发，还是在进行机器学习的数据预处理，掌握矩阵乘法的底层实现都是一项非常有价值的技能。

核心概念：什么是矩阵乘法？

在开始敲代码之前，让我们先通过数学的角度来理解一下什么是矩阵乘法。

维度兼容性规则

并不是任意两个矩阵都能相乘。假设我们有两个矩阵，矩阵 A 的维度是 $m \times n$，矩阵 B 的维度是 $p \times q$。要使乘法 $A \times B$ 有意义，必须满足：

$$n = p$$

也就是说，第一个矩阵的列数必须等于第二个矩阵的行数。如果不满足这个条件，乘法是无法进行的。

计算过程

结果矩阵 C 的维度将是 $m \times q$。结果矩阵中第 $i$ 行第 $j$ 列的元素 $C[i][j]$，是通过矩阵 A 的第 $i$ 行与矩阵 B 的第 $j$ 列对应元素相乘后再求和得到的。这个过程被称为“点积”。

让我们通过一个简单的例子来直观地看一下。

#### 示例 1：基础输入与输出

假设我们有两个 $2 \times 2$ 的矩阵：

输入：

Matrix A = {{1, 2}, 
           {3, 4}}
           
Matrix B = {{1, 1}, 
           {1, 1}}

计算逻辑：

结果矩阵左上角元素 (0,0) = $1 \times 1 + 2 \times 1 = 3$
结果矩阵右上角元素 (0,1) = $1 \times 1 + 2 \times 1 = 3$
结果矩阵左下角元素 (1,0) = $3 \times 1 + 4 \times 1 = 7$
结果矩阵右下角元素 (1,1) = $3 \times 1 + 4 \times 1 = 7$

输出：

{{3, 3}, 
 {7, 7}}

#### 示例 2：不同数值的计算

让我们再来看一组不同的数据，以确保你完全掌握了这个规律。

输入：

Matrix A = {{2, 4}, 
           {3, 4}}
           
Matrix B = {{1, 2}, 
           {1, 3}}

输出：

// 第一行：[(2*1 + 4*1), (2*2 + 4*3)] = [6, 14] -- 等等，GeeksforGeeks原文示例中的14在草稿中写成了16？不，2*2+4*3=4+12=16。正确。
// 第二行：[(3*1 + 4*1), (3*2 + 4*3)] = [7, 18]
{{6, 16}, 
 {7, 18}}

Java 实现标准方法

理解了数学原理后，让我们看看如何在 Java 中编写代码来实现它。为了演示任意大小矩阵的乘法，我们将定义两个不同维度的矩阵：矩阵 A ($4 \times 3$) 和矩阵 B ($3 \times 4$)。结果将是一个 $4 \times 4$ 的矩阵。

下面是一个完整的、带有详细中文注释的 Java 程序。你可以直接在你的 IDE 中运行它。

import java.io.*;

// 主类
class MatrixMultiplicationDemo {

    // 辅助函数：用于打印矩阵内容
    // M[][]: 待打印的矩阵
    // rowSize: 行数
    // colSize: 列数
    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();
        }
    }

    // 核心函数：用于计算两个矩阵 A[][] 和 B[][] 的乘积
    // row1, col1: 矩阵A的行数和列数
    // row2, col2: 矩阵B的行数和列数
    static void multiplyMatrix(int row1, int col1, int A[][],
                               int row2, int col2, int B[][]) {
        int i, j, k;

        // 步骤 1：打印输入矩阵，方便调试和查看
        System.out.println("
输入矩阵 A:");
        printMatrix(A, row1, col1);
        System.out.println("
输入矩阵 B:");
        printMatrix(B, row2, col2);

        // 步骤 2：检查维度兼容性
        // 如果矩阵A的列数不等于矩阵B的行数，则无法相乘
        if (col1 != row2) {
            System.out.println("
乘法无法进行：维度不兼容
"
                               + "请确保矩阵 A 的列数等于矩阵 B 的行数。");
            return;
        }

        // 步骤 3：创建结果矩阵 C
        // 结果矩阵的维度是 row1 x col2
        int C[][] = new int[row1][col2];

        // 步骤 4：执行三重循环进行乘法运算
        // 外层两个循环遍历结果矩阵 C 的每一个位置
        for (i = 0; i < row1; i++) {
            for (j = 0; j < col2; j++) {
                // 最内层循环计算点积
                for (k = 0; k < row2; k++)
                    C[i][j] += A[i][k] * B[k][j];
            }
        }

        // 步骤 5：打印结果矩阵
        System.out.println("
结果矩阵:");
        printMatrix(C, row1, col2);
    }

    // 主函数：程序入口
    public static void main(String[] args) {
        // 定义矩阵 A 为 4x3
        int row1 = 4, col1 = 3;
        int A[][] = { { 1, 1, 1 },
                      { 2, 2, 2 },
                      { 3, 3, 3 },
                      { 4, 4, 4 } };

        // 定义矩阵 B 为 3x4
        int row2 = 3, col2 = 4;
        int B[][] = { { 1, 1, 1, 1 },
                      { 2, 2, 2, 2 },
                      { 3, 3, 3, 3 } };

        // 调用函数进行乘法运算
        multiplyMatrix(row1, col1, A, row2, col2, B);
    }
}

程序输出：

输入矩阵 A:
1 1 1 
2 2 2 
3 3 3 
4 4 4 

输入矩阵 B:
1 1 1 1 
2 2 2 2 
3 3 3 3 

结果矩阵:
6 6 6 6 
12 12 12 12 
18 18 18 18 
24 24 24 24

深入解析：代码是如何工作的？

让我们剖析一下上面的核心代码，特别是这三层嵌套循环，这是整个算法的灵魂。

for (i = 0; i < row1; i++) {        // 遍历结果矩阵的行
    for (j = 0; j < col2; j++) {    // 遍历结果矩阵的列
        for (k = 0; k < row2; k++)  // 计算该位置的具体值（点积）
            C[i][j] += A[i][k] * B[k][j];
    }
}

外层循环 (i)：它的作用是定位我们在计算结果矩阵的哪一行。
中层循环 (j)：它的作用是定位我们在计算结果矩阵的哪一列。
内层循环 (k)：这是计算的核心。INLINECODE9d8490a3 的值取决于 A 的第 INLINECODEcc153119 行和 B 的第 INLINECODEe77bcddf 列。变量 INLINECODE41897897 就像是一个指针，同时向右移动 A 的行指针，向下移动 B 的列指针，将对应的一对数字相乘并累加。

复杂度分析与优化建议

作为开发者，我们不仅要写出能运行的代码，还要写出高效的代码。

#### 时间复杂度

你可以看到，我们有三个嵌套的循环。

外层循环运行 row1 次。
中层循环运行 col2 次。
内层循环运行 INLINECODEbee650be (或 INLINECODE1809bc32) 次。

因此，总的时间复杂度为 O(row1 \ col2 \ row2)。在最坏情况下，如果所有维度都为 N，时间复杂度就是 O(N^3)。这是一个立方级的复杂度，意味着当矩阵规模扩大时，计算时间会急剧增加。

针对上面的特定示例（4×3 和 3×4），计算次数是 $4 \times 4 \times 3 = 48$ 次乘法和加法。如果是 1000×1000 的矩阵，计算次数将达到 10 亿次级别！

#### 空间复杂度

空间复杂度为 O(row1 \* col2)，因为我们需要一个新的矩阵 C 来存储结果。如果不需要修改原矩阵，这是必须的。如果允许原地修改，某些特定算法可以降低空间消耗，但在 Java 中通常直接开辟新空间更安全且易于理解。

实战进阶：如何处理用户输入？

上面的代码使用了硬编码的数组。但在实际应用中，你可能需要让用户输入矩阵的大小和内容，或者从文件中读取。下面是一个使用 Scanner 类来处理动态输入的实用示例。这将让你的程序更加灵活。

import java.util.Scanner;

class DynamicMatrixInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // --- 矩阵 A 输入 ---
        System.out.println("请输入矩阵 A 的行数和列数 (用空格分隔):");
        int rowsA = scanner.nextInt();
        int colsA = scanner.nextInt();
        int[][] matrixA = new int[rowsA][colsA];

        System.out.println("请输入 " + (rowsA * colsA) + " 个元素作为矩阵 A 的内容:");
        for (int i = 0; i < rowsA; i++) {
            for (int j = 0; j < colsA; j++) {
                matrixA[i][j] = scanner.nextInt();
            }
        }

        // --- 矩阵 B 输入 ---
        System.out.println("请输入矩阵 B 的行数和列数 (用空格分隔):");
        int rowsB = scanner.nextInt();
        int colsB = scanner.nextInt();
        int[][] matrixB = new int[rowsB][colsB];

        System.out.println("请输入 " + (rowsB * colsB) + " 个元素作为矩阵 B 的内容:");
        for (int i = 0; i < rowsB; i++) {
            for (int j = 0; j < colsB; j++) {
                matrixB[i][j] = scanner.nextInt();
            }
        }

        scanner.close();

        // --- 验证与计算 ---
        if (colsA != rowsB) {
            System.out.println("错误：矩阵 A 的列数 (" + colsA + ") 
                               + "必须等于矩阵 B 的行数 (" + rowsB + ")。");
        } else {
            int[][] result = new int[rowsA][colsB];
            
            // 计算逻辑
            for (int i = 0; i < rowsA; i++) {
                for (int j = 0; j < colsB; j++) {
                    for (int k = 0; k < colsA; k++) {
                        result[i][j] += matrixA[i][k] * matrixB[k][j];
                    }
                }
            }

            // 打印结果
            System.out.println("
计算结果：");
            for (int[] row : result) {
                for (int column : row) {
                    System.out.print(column + " ");
                }
                System.out.println();
            }
        }
    }
}

常见陷阱与错误

在你编写自己的矩阵乘法程序时，有几个常见的错误可能会让你头疼，让我们提前规避它们：

数组越界异常：这是最常见的问题。通常发生在没有正确检查维度兼容性（INLINECODE714a03b4）之前就尝试访问 INLINECODE10881c5b 或 B[k][j]。务必在循环前先做检查！

整数溢出：我们在示例中使用了 INLINECODE0f9475a8 类型。但是，如果两个很大的 $200 \times 200$ 的矩阵相乘，中间累加的过程可能会很容易超过 INLINECODEcf4594e4 (约 21 亿)。在处理大规模数据或累加值可能很大的情况时，建议使用 INLINECODEf264fae9 类型甚至 INLINECODE17598a57 来存储结果。

初始化问题：在 Java 中，new int[row][col] 会自动将元素初始化为 0。但在某些语言或如果重用了数组，忘记重置累加器（或者没有在循环内正确清零）会导致结果错误。

实际应用场景

你可能会问，我为什么要手动实现这个？Java 库不是已经有现成的了吗（比如 Apache Commons Math 或 EJML）？

确实有。但在以下场景中，理解并手动编写它是很有价值的：

面试准备：这是大厂面试中非常经典的算法题，考察的是对多维数组和循环控制的理解。
嵌入式开发：在内存受限的环境中，你可能无法引入庞大的第三方库，必须手写精简的数学逻辑。
自定义逻辑：有时你需要的不是标准的乘法，而是带有权重的乘法或者对稀疏矩阵（大部分元素为0）的特殊优化。

总结与后续步骤

在本文中，我们全面地学习了如何在 Java 中实现两个任意大小矩阵的乘法。从数学定义到 Java 代码实现，再到复杂度分析和用户输入处理，我们现在有了一个扎实的理解。

关键要点回顾：

检查维度：永远不要假设两个矩阵可以相乘，先检查 col1 == row2。
三重循环：标准的时间复杂度是 O(N^3)，对于非常大的矩阵，这会成为瓶颈。
数据类型：注意整数溢出的风险，必要时使用 long。

下一步建议：

如果你对高性能计算感兴趣，我建议你接下来研究一下 Strassen 算法，它是一种比 O(N^3) 更快的矩阵乘法算法（约为 O(N^2.8)）。此外，也可以探索如何利用多线程来并行处理矩阵乘法，因为这是一个非常适合并行计算的任务。

希望这篇文章能帮助你更好地理解 Java 中的矩阵操作。如果你在尝试编写代码时遇到任何问题，欢迎随时回来检查我们的示例代码。祝编码愉快！

投稿给我们	如何建站？
vps是什么？	如何安装宝塔？
如何通过博客赚钱？	便宜wordpress托管方案
免费wordpress主题	这些都是免费方案

豆丁博客