Java Streams在井字棋胜利条件判断中的应用与局限性

public class TicTacToe {
    // NEIGHBOURS 定义了以当前棋子为中心，检查四个方向（水平、垂直、主对角线、副对角线）所需的两个邻居的相对偏移量。
    // 例如：{{0, -1}, {0, 1}} 表示水平方向，左邻居在 (0, -1)，右邻居在 (0, 1)。
    public static final int[][][] NEIGHBOURS =
           {{{0, -1}, {0, 1}},   // 水平方向：左(-1)和右(1)
            {{-1, 0}, {1, 0}},   // 垂直方向：上(-1)和下(1)
            {{-1, -1}, {1, 1}},  // 主对角线：左上(-1,-1)和右下(1,1)
            {{1, -1}, {-1, 1}}}; // 副对角线：右上(1,-1)和左下(-1,1)

    // 棋盘使用 List<List<String>> 表示，方便修改单元格内容
    private List<List<String>> board = new ArrayList<>(List.of(
        new ArrayList<>(Arrays.asList("1", "2", "3")), // 示例棋盘初始化，实际游戏中会填充玩家标记
        new ArrayList<>(Arrays.asList("4", "5", "6")),
        new ArrayList<>(Arrays.asList("7", "8", "9"))
    ));

    // 假设棋盘是3x3
    private static final int BOARD_SIZE = 3;

    // ... 后续方法 ...
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class TicTacToe {
    public static final int[][][] NEIGHBOURS =
           {{{0, -1}, {0, 1}},
            {{-1, 0}, {1, 0}},
            {{-1, -1}, {1, 1}},
            {{1, -1}, {-1, 1}}}; // 修正了副对角线的偏移量

    private List<List<String>> board = new ArrayList<>(List.of(
        new ArrayList<>(Arrays.asList("1", "2", "3")),
        new ArrayList<>(Arrays.asList("4", "5", "6")),
        new ArrayList<>(Arrays.asList("7", "8", "9"))
    ));

    private static final int BOARD_SIZE = 3;

    /**
     * 判断在给定位置 (row, col) 下棋后，当前玩家是否获胜。
     * 使用 Stream.anyMatch() 检查是否存在任何一个方向形成获胜组合。
     *
     * @param row 棋子所在的行
     * @param col 棋子所在的列
     * @return 如果形成获胜组合则返回 true，否则返回 false
     */
    public boolean isWinningMove(int row, int col) {
        // 将 NEIGHBOURS 数组转换为 Stream，并使用 anyMatch 检查是否有任何一个方向满足获胜条件
        return Arrays.stream(NEIGHBOURS)
            .anyMatch(isWinningCombination(row, col));
    }

    /**
     * 生成一个 Predicate，用于检查给定方向（由 neighbour 数组定义）是否构成获胜组合。
     *
     * @param row 棋子所在的行
     * @param col 棋子所在的列
     * @return 一个 Predicate，接收一个 int[][] 数组（代表一个方向的两个邻居偏移量），
     *         并判断该方向是否形成获胜组合。
     */
    public Predicate<int[][]> isWinningCombination(int row, int col) {
        return neighbour -> {
            int[] leftShift = neighbour[0];  // 左侧邻居的偏移量
            int[] rightShift = neighbour[1]; // 右侧邻居的偏移量
            String currentPlayer = getBoardValue(row, col); // 获取当前棋子（刚下的棋子）的值

            // 如果当前棋子是无效值（例如，边界外），则不可能获胜
            if ("INVALID INDEX".equals(currentPlayer)) {
                return false;
            }

            // 检查左侧邻居是否与当前棋子相同，且右侧邻居是否与当前棋子相同
            return currentPlayer.equals(getBoardValue(row + leftShift[0], col + leftShift[1]))
                && currentPlayer.equals(getBoardValue(row + rightShift[0], col + rightShift[1]));
        };
    }

    /**
     * 获取棋盘上指定位置的棋子值。
     * 包含边界检查，防止 ArrayIndexOutOfBoundsException。
     *
     * @param row 棋子所在的行
     * @param col 棋子所在的列
     * @return 棋子值，如果索引无效则返回 "INVALID INDEX"
     */
    public String getBoardValue(int row, int col) {
        // 边界检查
        if (row < 0 || row >= BOARD_SIZE || col < 0 || col >= BOARD_SIZE) {
            return "INVALID INDEX"; // 返回一个非法值，用于在 isWinningCombination 中判断为非获胜条件
        }
        return board.get(row).get(col); // 返回实际的棋子值
    }

    /**
     * 模拟下棋操作，更新棋盘。
     * @param row 行
     * @param col 列
     * @param playerSymbol 玩家标记 (如 "X" 或 "O")
     */
    public void makeMove(int row, int col, String playerSymbol) {
        if (row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE) {
            board.get(row).set(col, playerSymbol);
        } else {
            System.out.println("Invalid move: " + row + ", " + col);
        }
    }

    /**
     * 打印当前棋盘状态。
     */
    public void printBoard() {
        System.out.println("Current Board:");
        for (List<String> rowList : board) {
            System.out.println(String.join(" | ", rowList));
            if (!rowList.equals(board.get(BOARD_SIZE - 1))) {
                System.out.println("---------");
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        TicTacToe game = new TicTacToe();
        game.printBoard();

        // 模拟玩家 X 获胜的场景 (水平线)
        System.out.println("--- Player X makes moves ---");
        game.makeMove(0, 0, "X");
        game.makeMove(1, 0, "O"); // 干扰棋
        game.makeMove(0, 1, "X");
        game.makeMove(2, 0, "O"); // 干扰棋
        game.makeMove(0, 2, "X");
        game.printBoard();

        System.out.println("Player X's last move (0,2). Is it a winning move? " + game.isWinningMove(0, 2)); // 应该为 true

        // 重置棋盘
        game = new TicTacToe();
        game.makeMove(0, 0, "X");
        game.makeMove(1, 1, "X");
        game.makeMove(2, 2, "X");
        game.printBoard();
        System.out.println("Player X's last move (2,2). Is it a winning move? " + game.isWinningMove(2, 2)); // 应该为 true

        game = new TicTacToe();
        game.makeMove(0, 2, "O");
        game.makeMove(1, 1, "O");
        game.makeMove(2, 0, "O");
        game.printBoard();
        System.out.println("Player O's last move (2,0). Is it a winning move? " + game.isWinningMove(2, 0)); // 应该为 true

        game = new TicTacToe();
        game.makeMove(0, 0, "X");
        game.makeMove(0, 1, "O");
        game.makeMove(1, 0, "X");
        game.makeMove(1, 1, "O");
        game.makeMove(2, 2, "X");
        game.printBoard();
        System.out.println("Player X's last move (2,2). Is it a winning move? " + game.isWinningMove(2, 2)); // 应该为 false (没有形成直线)
    }
}