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

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

除了使用计数器标志之外，每当你增加计数器时返回false会更快，并在结束时返回true。这样可以防止不必要的代码运行

重构java代码的问题

2 个答案: