重构 java 代码的问题

Question

我现在正在做作业，有一个关于在 Java 中重构我的代码的问题。我现在正在玩数独，我需要检查 3x3 框是否有效。为此，我创建了一个包含所有框数的一维数组，然后比较它们的值。它现在正在工作，但实际上根本没有重构。我真的很想知道是否有任何方法可以减少所有这些复制粘贴。

public static boolean validFieldParts() {
    int counter = 0;
    boolean isValid = false;

    int[] copyArray1 = new int[field.length];
    int[] copyArray2 = new int[field.length];
    int[] copyArray3 = new int[field.length];
    int[] copyArray4 = new int[field.length];
    int[] copyArray5 = new int[field.length];
    int[] copyArray6 = new int[field.length];
    int[] copyArray7 = new int[field.length];
    int[] copyArray8 = new int[field.length];
    int[] copyArray9 = new int[field.length];


    // copy the array

    // 1 große Feld
    for (int i = 0; i < field.length / 3; i++) {
        for (int j = 0; j < field[i].length / 3; j++) {
            copyArray1[i * 3 + j] = field[i][j];
        }
    }

    // 2 große Feld
    for (int i = 0; i < field.length / 3; i++) {
        for (int j = 3; j < 6; j++) {
            copyArray2[i * 3 + j - 3] = field[i][j];
        }
    }

    // 3 große Feld
    for (int i = 0; i < field.length / 3; i++) {
        for (int j = 6; j < 9; j++) {
            copyArray3[i * 3 + j - 6] = field[i][j];
        }
    }

    // 4 große Feld
    for (int i = 3; i < 6; i++) {
        for (int j = 0; j < field[i].length / 3; j++) {
            copyArray4[(i - 3) * 3 + j] = field[i][j];
        }
    }

    // 5 große Feld
    for (int i = 3; i < 6; i++) {
        for (int j = 3; j < 6; j++) {
            copyArray5[(i - 3) * 3 + j - 3] = field[i][j];
        }
    }
    // 6 große Feld
    for (int i = 3; i < 6; i++) {
        for (int j = 6; j < 9; j++) {
            copyArray6[(i - 3) * 3 + j - 6] = field[i][j];
        }
    }

    // 7 große Feld
    for (int i = 6; i < 9; i++) {
        for (int j = 0; j < field[i].length / 3; j++) {
            copyArray7[(i - 6) * 3 + j] = field[i][j];
        }
    }

    // 8 große Feld
    for (int i = 6; i < 9; i++) {
        for (int j = 3; j < 6; j++) {
            copyArray8[(i - 6) * 3 + j - 3] = field[i][j];
        }
    }

    // 9 große Feld
    for (int i = 6; i < 9; i++) {
        for (int j = 6; j < 9; j++) {
            copyArray9[(i - 6) * 3 + j - 6] = field[i][j];
        }
    }

    Arrays.sort(copyArray1);
    Arrays.sort(copyArray2);
    Arrays.sort(copyArray3);
    Arrays.sort(copyArray4);
    Arrays.sort(copyArray5);
    Arrays.sort(copyArray6);
    Arrays.sort(copyArray7);
    Arrays.sort(copyArray8);
    Arrays.sort(copyArray9);

    for (int i = 1; i < copyArray1.length; i++) {
        if (copyArray1[i] == copyArray1[i - 1])
            counter++;
        else
            continue;
    }
    for (int i = 1; i < copyArray2.length; i++) {
        if (copyArray2[i] == copyArray2[i - 1])
            counter++;
        else
            continue;
    }
    for (int i = 1; i < copyArray3.length; i++) {
        if (copyArray3[i] == copyArray3[i - 1])
            counter++;
        else
            continue;
    }
    for (int i = 1; i < copyArray4.length; i++) {
        if (copyArray4[i] == copyArray4[i - 1])
            counter++;
        else
            continue;
    }
    for (int i = 1; i < copyArray5.length; i++) {
        if (copyArray5[i] == copyArray5[i - 1])
            counter++;
        else
            continue;
    }
    for (int i = 1; i < copyArray6.length; i++) {
        if (copyArray6[i] == copyArray6[i - 1])
            counter++;
        else
            continue;
    }
    for (int i = 1; i < copyArray7.length; i++) {
        if (copyArray7[i] == copyArray7[i - 1])
            counter++;
        else
            continue;
    }
    for (int i = 1; i < copyArray8.length; i++) {
        if (copyArray8[i] == copyArray8[i - 1])
            counter++;
        else
            continue;
    }
    for (int i = 1; i < copyArray9.length; i++) {
        if (copyArray9[i] == copyArray9[i - 1])
            counter++;
        else
            continue;
    }

    if (counter > 0)
        isValid = false;
    else
        isValid = true;

    return isValid;

}

Answer 1

这里是一个完整的重构。这里的改进：

创建了两个新方法：createCopy 和 isValid
删除了未使用的变量 counter 和 isValid
用一个二维数组替换了 9 个数组。

代码未经测试，请特别注意createCopy方法

// Creates each block of 9 digits copying digits from field 
// row, col are the block position, starting from upper left 0, 0 to
// last block 2, 2 
public static int[] createCopy(int[] field, int row, int col) {
    int[] copy = new int[9];
    for (int i = 3 * row; i < 3 * row + 3; i++) {
        for (int j = 3 * col; j < 3 * col + 3; j++) {               
            copy[(i - 3 * row) * 3 + j - 3 * col] = field[i][j];              
        }
    } 
    return copy;
}

// Check if one block is valid
private static boolean isValid(int[] copyArray) {
    Arrays.sort(copyArray);
    for (int i = 1; i < copyArray.length; i++) {
        if (copyArray[i] == copyArray[i - 1]) {
            // Exit immediately if not valid
            return false;
        }
    }   
    return true;
}

// Create blocks, then validate them
// At first not valid block return false
public static boolean validFieldParts() {
    int[][] copyArrays = new int[3][3];

    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            copyArrays[row][col] = createCopy(field, row, col);
        }
    }


    for (int[] copyArray : copyArrays) {
        if (!isValid(copyArray)) {
           // Exit immediately if not valid
           return false;
        }
    }
    return true;
}

Answer 2

我不会使用 9 个不同的数组和 9 个不同的循环来表示 9 的每个部分，而是使用另一个嵌套的 for 循环，它使用相同的数组迭代每个集群。

//Iterate over each 'block'
for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 3; col++) {
        //Iterate over each cell in the block
        for (int i = row*3; i < (row+1)*3; i++) {
            for (int j = col*3; j < (col+1)*3; j++) {
                copyArray[(i - 3) * 3 + j - 3] = field[i][j];
            }
        }

        //Sort array and do duplication check here - return false if dupe found
    }
}
return true

这会减少代码的长度，尽管它可能不会更有效率。

不使用计数器标志，而是在您递增计数器时将 return false 改为 return false 并在最后变为 return true 会快得多。这将防止不必要的代码来自运行

重构 java 代码的问题

Problems with refactoring java code

java

refactoring

loops