幻方（magic square）是一个n阶方阵，其每行、每列以及两条主对角线上的数字之和都相等。这个相等的和被称为幻和（magic constant）。本教程的目标是编写一个java程序，从文件中读取一系列4x4的整数矩阵，并判断每个矩阵是否为幻方。文件通过一个特定的哨兵值（-999）来指示数据流的结束。
为了判断一个4x4矩阵是否为幻方，我们需要执行以下步骤：
在实现幻方检测时，开发者常会遇到一些逻辑和编程错误。以下是一个常见初始代码示例及其存在的问题：
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
class square {
public static void main(String[] args) throws IOException {
File data = new File("Lab8Data.txt");
Scanner input = new Scanner(data);
// 问题1：数组和总和变量在循环外初始化，导致前一个幻方的数据影响下一个
int[][] array = new int[4][4];
int[] rowTotal = new int[4];
int[] columnTotal = new int[4];
// 问题2：首次读取仅填充了array[0]行，且读取方式不规范
for (int row = 0; row < array.length; row++)
array[0][row] = input.nextInt();
// 问题3：循环条件依赖array[0][0]，但其值可能在循环内部被修改或未正确更新
while (array[0][0] != -999) {
// 问题4：后续矩阵元素读取逻辑错误，跳过了array[0][0]之后的元素
for (int column = 1; column < array.length; column++)
for (int row = 0; row < 4; row++)
array[column][row] = input.nextInt();
// 打印矩阵（这部分通常没问题）
for (int column = 0; column < array.length; column++) {
for (int row = 0; row < array.length; row++)
System.out.print(array[column][row] + " ");
System.out.println();
}
// 问题5：行和计算正确，但列和计算的索引错误
for (int column = 0; column < array.length; column++)
for (int row = 0; row < array.length; row++)
rowTotal[column] += array[column][row]; // 实际是计算列和并存入rowTotal
for (int row = 0; row < array.length; row++)
for (int column = 0; column < array.length; column++)
columnTotal[row] += array[column][row]; // 实际是计算行和并存入columnTotal
// 对角线计算（第一条对角线正确）
int diagonalOne = 0;
for(int row = 0; row < array.length; row++)
diagonalOne = diagonalOne + array[row][row];
// 问题6：对角线判断逻辑和变量作用域问题，以及结果打印位置不当
int otherDiagonal = 0;
for (int row = 0; row < array.length; row++) {
otherDiagonal = otherDiagonal + array[row][Math.abs(3 - row)]; // Math.abs(3 - row) 对于4x4是正确的
// 以下变量和逻辑在循环内重复初始化和判断，导致错误
int rows = rowTotal[0];
boolean rowEqual = true;
for (int r = 0; r < array.length; r++)
if (rowTotal[r] != r) // 问题7：比较对象错误，应与rows（或rowTotal[0]）比较
rowEqual = false;
int col = columnTotal[0];
boolean columnEqual = true;
for (int column = 0; column < array.length; column++)
if (rowTotal[column] != col) // 问题8：比较对象错误，应是columnTotal[column]
columnEqual = false;
int diagonal = diagonalOne;
boolean diagonalEqual = true;
if (otherDiagonal != diagonal) // 问题9：otherDiagonal在循环内累加，判断时机错误
diagonalEqual = false;
boolean isMagic = false;
if (rowEqual && columnEqual && diagonalEqual)
if (rows == col && col == diagonal)
isMagic = true;
if (isMagic)
System.out.println("Is a magic square");
else
System.out.println("NOT a magic square");
// 问题10：仅读取了下一组数据的第一行，而非整个矩阵
for (int r = 0; r < 4; r++)
array[0][r] = input.nextInt();
}
}
}
}主要问题总结：
为了解决上述问题，我们将分步重构代码。
立即学习“Java免费学习笔记（深入）”；
为了确保每次处理一个全新的矩阵，所有与矩阵相关的变量（array、rowTotal、columnTotal）都应在每次循环开始时重新初始化。同时，采用 while(true) 循环结合 break 语句来优雅地处理哨兵值。
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class MagicSquareChecker { // 建议类名更具描述性
public static void main(String[] args) throws IOException {
File data = new File("Lab8Data.txt");
Scanner input = new Scanner(data);
while (true) { // 使用无限循环，通过哨兵值退出
// 每次循环开始时，重新初始化矩阵和总和数组
int[][] array = new int[4][4];
int[] rowTotal = new int[4];
int[] columnTotal = new int[4];
// 首先读取第一个数字，判断是否为哨兵
if (!input.hasNextInt()) { // 检查是否有下一个整数，防止文件末尾异常
break; // 文件结束，退出循环
}
int number = input.nextInt();
if (number == -999) { // 遇到哨兵值，退出循环
break;
}
array[0][0] = number; // 第一个数字是矩阵的array[0][0]
// 读取矩阵的其余部分
// 先读取第一行的剩余元素
for (int column = 1; column < array[0].length; column++) {
if (!input.hasNextInt()) { // 确保有足够的数字
System.err.println("Error: Insufficient numbers in file for a 4x4 matrix.");
return; // 或处理错误，例如跳过当前矩阵
}
array[0][column] = input.nextInt();
}
// 再读取剩余的行
for (int row = 1; row < array.length; row++) {
for (int column = 0; column < array[row].length; column++) {
if (!input.hasNextInt()) {
System.err.println("Error: Insufficient numbers in file for a 4x4 matrix.");
return;
}
array[row][column] = input.nextInt();
}
}
// 打印当前读取的矩阵
System.out.println("Current Matrix:");
for (int r = 0; r < array.length; r++) {
for (int c = 0; c < array[r].length; c++) {
System.out.print(array[r][c] + "\t"); // 使用制表符对齐
}
System.out.println();
}
// ... 后续的计算和判断逻辑将在此处添加
}
input.close(); // 关闭Scanner资源
}
}修正行和与列和的计算逻辑，确保索引正确。
// ... (在while循环内部，打印矩阵之后)
// 计算行和
for (int row = 0; row < array.length; row++) {
for (int column = 0; column < array[row].length; column++) {
rowTotal[row] += array[row][column];
}
}
// 计算列和 (修正了索引)
for (int column = 0; column < array.length; column++) {
for (int row = 0; row < array.length; row++) {
columnTotal[column] += array[row][column];
}
}
// 计算主对角线和 (从左上到右下)
int diagonalOne = 0;
for (int i = 0; i < array.length; i++) {
diagonalOne += array[i][i];
}
// 计算副对角线和 (从右上到左下)
int otherDiagonal = 0;
for (int i = 0; i < array.length; i++) {
otherDiagonal += array[i][array.length - 1 - i]; // 更通用的副对角线索引
}
// ... (后续的判断逻辑)将所有判断逻辑放在计算完成后，确保只判断一次，并且比较基准正确。
// ... (在所有求和计算之后)
// 设定幻和的基准值，例如第一行的和
int magicSum = rowTotal[0];
boolean isMagic = true; // 假设是幻方，如果发现不符合条件则设为false
// 1. 检查所有行和是否相等且等于magicSum
for (int r = 0; r < array.length; r++) {
if (rowTotal[r] != magicSum) {
isMagic = false;
break; // 发现不相等即可退出
}
}
// 如果已经确定不是幻方，则无需继续检查
if (!isMagic) {
System.out.println("NOT a magic square\n");
continue; // 跳到下一个矩阵的处理
}
// 2. 检查所有列和是否相等且等于magicSum
for (int c = 0; c < array.length; c++) {
if (columnTotal[c] != magicSum) {
isMagic = false;
break;
}
}
if (!isMagic) {
System.out.println("NOT a magic square\n");
continue;
}
// 3. 检查两条对角线和是否相等且等于magicSum
if (diagonalOne != magicSum || otherDiagonal != magicSum) {
isMagic = false;
}
// 最终判断并打印结果
if (isMagic) {
System.out.println("Is a magic square\n");
} else {
System.out.println("NOT a magic square\n");
}
} // 结束while循环
input.close();
}
}在某些情况下，我们不需要将所有行和、列和存储在单独的数组中。我们可以计算出第一个幻和（例如，第一行的和或主对角线的和），然后遍历其他行、列和对角线，一旦发现不匹配，立即将 isMagic 设为 false 并停止检查。这种方法可以减少内存使用。
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class OptimizedMagicSquareChecker {
public static void main(String[] args) throws IOException {
File data = new File("Lab8Data.txt");
Scanner input = new Scanner(data);
while (true) {
int[][] array = new int[4][4];
boolean isMagic = true; // 假设是幻方
// 读取第一个数字，判断是否为哨兵
if (!input.hasNextInt()) {
break;
}
int number = input.nextInt();
if (number == -999) {
break;
}
array[0][0] = number;
// 读取矩阵的其余部分
for (int r = 0; r < array.length; r++) {
for (int c = (r == 0 ? 1 : 0); c < array[r].length; c++) { // 从array[0][1]开始，其他行从array[r][0]开始
if (!input.hasNextInt()) {
System.err.println("Error: Insufficient numbers in file for a 4x4 matrix.");
input.close();
return;
}
array[r][c] = input.nextInt();
}
}
// 打印当前读取的矩阵
System.out.println("Current Matrix:");
for (int r = 0; r < array.length; r++) {
for (int c = 0; c < array[r].length; c++) {
System.out.print(array[r][c] + "\t");
}
System.out.println();
}
// 计算幻和基准值（使用主对角线和）
int magicSum = 0;
for (int i = 0; i < array.length; i++) {
magicSum += array[i][i];
}
// 检查副对角线和
int otherDiagonalSum = 0;
for (int i = 0; i < array.length; i++) {
otherDiagonalSum += array[i][array.length - 1 - i];
}
if (otherDiagonalSum != magicSum) {
isMagic = false;
}
// 检查行和
if (isMagic) { // 只有当前仍是幻方才继续检查
for (int r = 0; r < array.length; r++) {
int currentRowSum = 0;
for (int c = 0; c < array[r].length; c++) {
currentRowSum += array[r][c];
}
if (currentRowSum != magicSum) {
isMagic = false;
break;
}
}
}
// 检查列和
if (isMagic) { // 只有当前仍是幻方才继续检查
for (int c = 0; c < array.length; c++) {
int currentColSum = 0;
for (int r = 0; r < array.length; r++) {
currentColSum += array[r][c];
}
if (currentColSum != magicSum) {
isMagic = false;
break;
}
}
}
// 最终判断并打印结果
if (isMagic) {
System.out.println("Is a magic square\n");
} else {
System.out.println("NOT a magic square\n");
}
}
input.close();
}
}通过上述重构和优化，我们得到了一个功能正确且更健壮的幻方检测程序。
关键学习点和最佳实践：
掌握这些原则，将有助于编写出更高效、更可靠的Java应用程序。
以上就是Java编程：识别幻方矩阵的完整教程的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
392
收藏
