java 随机生成数独

要在 Java 中随机生成数独，可以按照以下步骤进行：

1. 创建一个 9x9 的二维数组，用于表示数独的初始状态。
2. 随机选择某些格子，并将其填上一个 1~9 的随机数。
3. 使用递归回溯算法，对已经填好的格子进行检查，生成符合数独规则的数独。
4. 将数独的初始状态中一些格子的数字清空，得到最终的随机数独。

下面是一个简单的 Java 代码示例，可以生成一个随机的数独：

import java.util.*;

public class SudokuGenerator {
    private static final int SIZE = 9;
    private static final int EMPTY = 0;
    private int[][] board;

    public SudokuGenerator() {
        board = new int[SIZE][SIZE];
    }

    public void generate() {
        // 随机填一些格子
        Random random = new Random();
        for (int i = 0; i < SIZE; i++) {
            for (int j = 0; j < SIZE; j++) {
                if (random.nextInt(4) == 0) {
                    board[i][j] = random.nextInt(9) + 1;
                }
            }
        }

        // 生成符合规则的数独
        generateSudoku(0, 0);

        // 清空一些格子，得到最终的随机数独
        int emptyCount = random.nextInt(21) + 30;
        for (int i = 0; i < emptyCount; i++) {
            int row = random.nextInt(SIZE);
            int col = random.nextInt(SIZE);
            if (board[row][col] != EMPTY) {
                board[row][col] = EMPTY;
            }
        }
    }

    private boolean generateSudoku(int row, int col) {
        if (col == SIZE) {
            col = 0;
            row++;
            if (row == SIZE) {
                return true;
            }
        }

        if (board[row][col] != EMPTY) {
            return generateSudoku(row, col + 1);
        }

        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= SIZE; i++) {
            numbers.add(i);
        }
        Collections.shuffle(numbers);

        for (int number : numbers) {
            if (isValid(row, col, number)) {
                board[row][col] = number;
                if (generateSudoku(row, col + 1)) {
                    return true;
                }
                board[row][col] = EMPTY;
            }
        }

        return false;
    }

    private boolean isValid(int row, int col, int number) {
        for (int i = 0; i < SIZE; i++) {
            if (board[row][i] == number || board[i][col] == number) {
                return false;
            }
        }

        int boxRow = row - row % 3;
        int boxCol = col - col % 3;
        for (int i = boxRow; i < boxRow + 3; i++) {
            for (int j = boxCol; j < boxCol + 3; j++) {
                if (board[i][j] == number) {
                    return false;
                }
            }
        }

        return true;
    }

    public void print() {
        for (int i = 0; i < SIZE; i++) {
            for (int j = 0; j < SIZE; j++) {
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        SudokuGenerator generator = new SudokuGenerator();
        generator.generate();
        generator.print();
    }
}

该代码使用了递归回溯算法，生成符合数独规则的数独。在生成过程中，会随机填一些格子，并将一些格子清空，得到最终的随机数独。