Java 实例 – 九九乘法表（千字长文）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

九九乘法表是编程学习中的经典入门案例，它通过简单的数学逻辑和循环结构，帮助开发者理解编程语言的核心控制流程。在 Java 这门面向对象的语言中实现九九乘法表，既能巩固基础语法，又能为后续复杂算法的编写打下坚实基础。本文将以 Java 实例 – 九九乘法表 为切入点，从循环逻辑、代码优化到进阶技巧，逐步拆解其实现过程，并通过实例代码和形象比喻，让读者轻松掌握这一知识点。

实现九九乘法表的基础步骤

循环结构的基石：for循环

九九乘法表的核心在于通过循环生成多行多列的输出结果。在 Java 中，for 循环是最常用的循环结构。我们可以将乘法表的行数和列数分别映射为外层和内层循环的变量。

形象比喻：

想象乘法表是一张“数字织物”，外层循环控制“行数”（如从 1 到 9），内层循环控制“列数”（如从 1 到当前行数）。每一行的列数会随行数递增，就像编织时每一行的线头数量逐渐增加。

代码示例：

public class MultiplicationTable {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) { // 外层循环控制行数
            for (int j = 1; j <= i; j++) { // 内层循环控制列数
                System.out.print(j + "×" + i + "=" + (i * j) + "\t"); // 输出格式化字符串
            }
            System.out.println(); // 每行结束后换行
        }
    }
}

代码解析：

• 外层循环变量 i：从 1 到 9，代表当前行的乘数（如第 3 行的乘数是 3）。
• 内层循环变量 j：从 1 到 i，代表被乘数（如第 3 行的被乘数从 1 到 3）。
• 输出格式：使用 \t 实现列对齐，println() 确保每行结束后换行。

变量与表达式的配合使用

在乘法表中，表达式 i * j 生成具体数值，但实际输出顺序需要调整。例如，第 i 行的第 j 列应显示 j × i = i*j，而非 i × j。因此，变量 i 和 j 的位置需严格对应。

易错点提醒：

若将 i 和 j 的位置调换（如 i × j），虽然数值结果相同，但表达式逻辑会与乘法表的常规书写方式冲突（如 3×1 和 1×3 虽等价，但前者更符合表的递增规律）。

输出格式的控制

乘法表的可读性依赖于整齐的列对齐。通过 System.out.print() 和 \t（制表符），可以实现每列的固定间距。若数值位数不一致（如 9×9=81），可使用 String.format() 进一步格式化：

进阶代码示例：

System.out.printf("%d×%d=%-3d\t", j, i, i * j); // %-3d 表示左对齐且占位3位

效果对比：

• 普通输出：1×1=1 2×2=4（数值位数不一致时可能错位）。
• 格式化输出：1×1=1  2×2=4 （通过占位符保证对齐）。

代码示例与详细解析

完整代码与运行结果

public class MultiplicationTable {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.printf("%d×%d=%-3d\t", j, i, i * j);
            }
            System.out.println();
        }
    }
}

运行结果：

1×1=1  
1×2=2  2×2=4 
1×3=3  2×3=6  3×3=9 
...（中间省略）...
1×9=9  2×9=18  3×9=27  ...  9×9=81 

进阶技巧：优化与多样化实现

减少循环次数的技巧

传统实现中，外层循环从 1 到 9，内层循环从 1 到 i，总共有 (1+2+\cdots+9 = 45) 次运算。若希望减少循环次数，可以将外层和内层循环的范围统一为 1 到 9，并通过条件判断筛选有效输出：

for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= 9; j++) {
        if (j <= i) { // 仅当 j ≤ i 时输出
            System.out.printf("%d×%d=%-3d\t", j, i, i * j);
        }
    }
    System.out.println();
}

优化对比：

• 原始方法：45 次内层循环迭代。
• 优化方法：81 次迭代，但通过条件判断减少实际运算量。
• 适用场景：当循环体逻辑复杂时，优化方法可能更高效。

使用 while 循环实现

for 循环适合已知循环次数的场景，而 while 循环则需手动管理变量。以下代码通过 while 循环实现相同功能：

public class MultiplicationTable {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 9) {
            int j = 1;
            while (j <= i) {
                System.out.printf("%d×%d=%-3d\t", j, i, i * j);
                j++;
            }
            System.out.println();
            i++;
        }
    }
}

关键点：

• 变量初始化：需在循环外手动声明 i 和 j。
• 循环条件更新：每次循环结束需手动递增 i 和 j。

倒序输出的九九乘法表

若希望输出从 9×9 开始倒序排列，只需调整循环的起始值和递减方向：

for (int i = 9; i >= 1; i--) {
    for (int j = 1; j <= i; j++) {
        System.out.printf("%d×%d=%-3d\t", j, i, i * j);
    }
    System.out.println();
}

运行结果：

1×9=9  2×9=18  ...  9×9=81 
1×8=8  2×8=16  ...  8×8=64 
...
1×1=1  

常见问题与调试技巧

问题 1：输出结果错位或不完整

现象：表格列数不匹配，或某些行未完全显示。
原因：内层循环的条件判断错误（如 j < i 代替 j <= i）。
解决方案：检查循环终止条件，确保 j 的范围覆盖 1 到 i。

问题 2：数值计算错误

现象：输出的乘积结果不正确。
原因：表达式顺序错误（如 j * i 写成 i + j）。
解决方案：验证 i * j 是否正确，并确认变量类型无溢出风险。

总结与学习建议

通过本文的讲解，读者应能掌握以下核心知识点：

1. 循环结构：利用 for 和 while 循环控制多行多列的输出逻辑。
2. 格式化输出：通过 printf 实现整齐的列对齐。
3. 代码优化：通过条件判断或循环范围调整提升效率。

学习建议：

• 尝试将代码改写为方法（如 printTable()），提升代码复用性。
• 探索其他语言（如 Python）的实现方式，对比语法差异。
• 将九九乘法表扩展为 N×N 的乘法表，增强参数化思维。

九九乘法表虽看似简单，却是理解编程逻辑的重要跳板。通过反复实践与变式练习，开发者能够逐步构建对循环、变量和控制流的深刻理解，为后续的算法学习奠定基础。