java - 如何压缩数组的原始整数数据？

Question

我正在使用斯坦福大学的 cs106a 类(class)自学 Java。目前我正在阅读《Java 的艺术与科学》一书的第 10 章。问题是编写一个 3x3 幻方。练习:

1. 您必须编写一个 3x3 数组
2. 数组(幻方)的每条边必须等于 15

问题:
我写的程序可以运行，作业也完成了，这个问题是自学的。作为初学者，我想改进方法 SumOfSides() 并使其更小、更高效。我尝试用此方法迭代数组，但仍然存在问题。有没有办法让它更有效率？

public void run() {
    //set the font
    setFont("Helvetica-40");


    //fill the array
    fillArray();

    //sum up all sides 
    SumOfSides();

    //check if all of the sides in the magic square array equal 15: 
    checkSides(mSqr);

    //I used this for debugging purposes only:
    //showSides();

}

//for debugging purposes:
public void showSides() {

    println(sumRight0);
    println(sumRight1);

    println(sumRight2);
    println(sumBottom0);
    println(sumBottom1);
    println(sumBottom2);
    println(sumDiagonalUp);
    println(sumDiagonalDown);


}

public void SumOfSides() {
    sumRight0 = mSqr[0][0] + mSqr[0][1] + mSqr[0][2];
    sumRight1 = mSqr[1][0] + mSqr[1][1] + mSqr[1][2];
    sumRight2 = mSqr[2][0] + mSqr[2][1] + mSqr[2][2];

    sumBottom0 =mSqr[0][0] + mSqr[1][0] + mSqr[2][0];
    sumBottom1 =mSqr[0][1] + mSqr[1][1] + mSqr[2][1];
    sumBottom2 =mSqr[0][2] + mSqr[1][2] + mSqr[2][2];

    sumDiagonalUp = mSqr[2][0] + mSqr[1][1]+ mSqr[0][2];

    sumDiagonalDown = mSqr[0][0] + mSqr[1][1] + mSqr[2][2];

}

/*This predicate method checks if the sides
  of the array add up to 15: */

public boolean checkSides(int[][] myArray) {

    if (sumRight0 ==15 && sumRight1 ==15&& sumRight2==15 && sumBottom0==15&& sumBottom1==15&&
         sumBottom2==15&& sumDiagonalUp==15&&sumDiagonalDown==15) {
        println("True, this is a Magic Square");
        return true;
    } else {
        println("False, the sides do not equal 15");
        return false;
    }

}

public void fillArray() {

    int num =0;
    for(int row=0; row <3; row++) {

        for (int col=0; col<3; col++) {
            num=readInt("");
            mSqr[row][col]=num;
        }
    }

    /*Test array values here to see
     * if they were entered correctly.
     */
    //println(mSqr[1][2]); //should be 6
    //println(mSqr[2][0]); //should be 7

}


    //instance variables: 
    int[][] mSqr= new int[3][3];

    List<List<Integer>> new1 = new ArrayList<>();

    private int sumRight0;
    private int sumRight1;
    private int sumRight2;
    private int sumBottom0;
    private int sumBottom1;
    private int sumBottom2;

    private int sumDiagonalUp;
    private int sumDiagonalDown;

}

Answer 1

也许唯一的事情就是可读性。您可以获取这些值并将它们移动到更可读的变量中:

int topLeft = mSqr[0][0];
int topMid = mSqr[0][1];
...
int sumLeft = topLeft + midLeft + bottomLeft;
int sumRight = topRight = midRight + bottomRight;
...

为了解决您对使其更小的担忧，我认为，正如您所提到的，如果您要进行 6 个总和，每个总和有 3 个值，那么将总和转换为循环肯定不值得。此外，每个总和的每一项对于一个或两个其他总和是公共(public)的，这不会提供太多重叠。如果您执行较大的求和(求和中的项数较多，而不是总值)，那么在可读性/SLOC 参数上也许是值得的。

假设你仍然想做一个循环，你可以做类似的事情

 sumLeft = 0;
 sumRight = 0;
 sumTop = 0;
 sumBottom = 0;
 sumDiagonalUp = 0;
 sumDiagonalDown = 0;
 for(int i = 0; i < mSqr.length; i++) {
     for(int j = 0; j < mSqr[i].length; j++) {
         if (i == 0) {
            sumLeft += mSqr[i][j];
         }
         if (i == mSqr.length - 1) {
            sumRight += mSqr[i][j];
         }
         if (j == 0) {
            sumTop += mSqr[i][j];
         }
         if (j == mSqr[i].length) {
            sumBottom += mSqr[i][j];
         }
         if (i == j) {
            sumDiagonalDown += mSqr[i][j];
         }
         if (i + j == mSqr.length - 1) {
            sumDiagonalUp += mSqr[i][j];
         }
     }
 }

循环仅对大型幻方提供好处。另外，与您的实现相比，我对您的描述感到困惑。您似乎正在对每一行和每一列以及正方形的两条对角线求和，而不是对 4 条边和对角线求和。