Java Stream API辅助实现井字棋胜利逻辑：一种混合方法

本文探讨了如何在java中利用stream api辅助实现井字棋（tic-tac-toe）的胜利条件判断。针对井字棋需要检查水平、垂直及对角线排列的复杂性，文章指出仅依赖stream进行元素频率统计的局限性。教程提出了一种结合命令式逻辑与stream `anymatch` 方法的混合解决方案。该方案通过定义相对坐标偏移量来高效检测围绕最新落子点的潜在胜利组合，确保了逻辑清晰与性能优化，展示了stream api在复杂游戏逻辑中作为辅助工具的有效应用。

在开发井字棋这类棋盘游戏时，判断玩家是否获胜是核心逻辑之一。井字棋的胜利条件在于同一玩家的三个棋子在水平、垂直或对角线上形成一条直线。本文将深入探讨如何利用Java Stream API来辅助实现这一复杂的胜利条件判断，并指出纯粹依赖Stream进行某些复杂逻辑判断的局限性，最终提供一个结合命令式编程与函数式风格的混合解决方案。

井字棋胜利条件判断的挑战

传统的井字棋胜利判断需要遍历棋盘的每一行、每一列以及两条对角线，检查是否有连续三个相同的棋子。这涉及到二维数组或列表的遍历以及复杂的条件逻辑。

例如，如果有一个扁平化的棋盘列表 List listTicTacToe = List.of("1", "2", "3", "4", "5", "6", "7", "8", "9");，并尝试使用以下Stream操作来判断胜利：

// 方案1：检查是否有某个数字出现3次
List res2 = listTicTacToe.stream()
        .filter(number -> Collections.frequency(listTicTacToe, number) == 3)
        .collect(Collectors.toList());
boolean isWinner = !res2.isEmpty();

// 方案2：通过分组计数检查是否有某个元素出现3次
List res = listTicTacToe.stream()
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
        .entrySet()
        .stream()
        .filter(e -> e.getValue() == 3)
        .map(e -> e.getKey())
        .collect(Collectors.toList());

上述两种方案都无法正确判断井字棋的胜利。它们仅仅统计了列表中某个元素出现的次数。在井字棋中，即使某个玩家有三个或更多棋子在棋盘上，如果这些棋子没有排列成一条直线，也不能算作胜利。胜利条件是基于棋子在棋盘上的位置关系，而不是简单的数量统计。因此，需要一种能够理解棋盘空间结构的判断方法。

立即学习“Java免费学习笔记（深入）”；

混合式解决方案：结合命令式逻辑与Stream

由于井字棋的胜利判断本质上涉及到对棋子位置的检查，纯粹的Stream操作很难直接表达“在特定方向上连续三个”这种空间关系。然而，我们可以巧妙地将Stream API与传统的命令式逻辑结合起来，以更清晰、更高效的方式实现胜利判断。

核心思想是：当玩家下了一个棋子后，我们只需要检查围绕这个新落子点可能形成的胜利组合，而不是扫描整个棋盘。这大大提高了效率。

1. 棋盘表示

首先，我们需要一个能够表示井字棋盘的数据结构。一个 List> 是一个合适的选择，它允许我们通过行和列索引访问棋盘上的每个位置。

private List> board = List.of(
    Arrays.asList("1", "4", "7"), // 示例初始值，实际游戏中会是空或玩家标记
    Arrays.asList("2", "5", "8"),
    Arrays.asList("3", "6", "9")
);

2. 定义胜利组合的相对偏移量

为了检查水平、垂直和对角线，我们可以定义一个静态数组来存储相对偏移量。每个偏移量组代表一个潜在的胜利方向，包含两个子偏移量，分别指向当前棋子左右（或上下、斜上斜下）的相邻位置。

public static final int[][][] NEIGHBOURS = {
    {{0, -1}, {0, 1}},   // 水平方向：当前点左右各一个
    {{-1, 0}, {1, 0}},   // 垂直方向：当前点上下各一个
    {{-1, -1}, {1, 1}},  // 主对角线：当前点左上和右下各一个
    {{1, -1}, {-1, 1}}   // 副对角线：当前点左下和右上各一个
};

注意： 原始代码中的对角线定义 {{1, 1}, {-1, -1}} 实际上是重复了主对角线的方向，只是方向相反。为了覆盖所有四个方向（水平、垂直、主对角、副对角），应修正为 {{1, -1}, {-1, 1}} 来表示副对角线。

VISBOOM

AI虚拟试衣间，时尚照相馆。

下载

3. 实现 isWinningMove 方法

这个方法将接收最新落子的行和列，并利用Stream API的 anyMatch 功能来检查是否存在任何一个胜利组合。

public boolean isWinningMove(int row, int col) {
    // 将NEIGHBOURS数组转换为Stream，并检查是否有任何一个组合满足胜利条件
    return Arrays.stream(NEIGHBOURS)
        .anyMatch(isWinningCombination(row, col));
}

Stream.anyMatch() 方法非常适合这里，因为它可以在找到第一个匹配项时立即停止，这对于性能优化非常有利。

4. 实现 isWinningCombination 谓词

isWinningCombination 方法返回一个 Predicate，这个谓词用于检查给定的偏移量组（一个 int[][] 数组）是否构成了胜利组合。

public Predicate isWinningCombination(int row, int col) {
    return neighbour -> {
        int[] leftShift = neighbour[0];  // 第一个相邻点的偏移量
        int[] rightShift = neighbour[1]; // 第二个相邻点的偏移量
        String currentPlayer = getBoardValue(row, col); // 获取当前落子点的玩家标记

        // 检查左侧相邻点、当前点、右侧相邻点是否都属于同一玩家
        return getBoardValue(row + leftShift[0], col + leftShift[1])
                    .equals(currentPlayer)
            && getBoardValue(row + rightShift[0], col + rightShift[1])
                    .equals(currentPlayer);
    };
}

这个谓词的工作原理是：对于每个 neighbour 数组（代表一个方向，如水平），它取出两个偏移量 leftShift 和 rightShift。然后，它获取当前落子点的玩家标记 currentPlayer，并检查通过 leftShift 和 rightShift 计算出的两个相邻位置的棋子是否也属于 currentPlayer。

5. 实现 getBoardValue 辅助方法

为了安全地获取棋盘上的值并处理越界情况，我们需要一个辅助方法。

public String getBoardValue(int row, int col) {
    // 检查索引是否越界
    if (row < 0 || row >= board.size() || col < 0 || col >= board.get(row).size()) {
        return "INVALID INDEX"; // 返回一个非法值，确保`equals()`检查会失败
    }
    return board.get(row).get(col); // 返回实际的棋盘值
}

这个方法在索引越界时返回一个特殊的字符串（例如 "INVALID INDEX"），这样在 isWinningCombination 中进行 equals() 比较时，它就不会与任何玩家的标记匹配，从而避免了 IndexOutOfBoundsException 或 NullPointerException。

完整示例代码

将上述组件整合到一个 TicTacToe 类中，即可形成完整的胜利判断逻辑。

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class TicTacToe {
    // 定义胜利组合的相对偏移量：水平、垂直、主对角线、副对角线
    public static final int[][][] NEIGHBOURS = {
           {{{0, -1}, {0, 1}},   // 水平方向：当前点左右各一个
            {{-1, 0}, {1, 0}},   // 垂直方向：当前点上下各一个
            {{-1, -1}, {1, 1}},  // 主对角线：当前点左上和右下各一个
            {{1, -1}, {-1, 1}}}}; // 副对角线：当前点左下和右上各一个

    // 井字棋盘，使用List>表示
    // Arrays.asList() 用于内部列表，因为它允许修改元素值，但不允许结构性修改
    // List.of() 创建的是不可变列表
    private List> board = List.of(
        Arrays.asList(" ", " ", " "), // 初始为空格，代表空位
        Arrays.asList(" ", " ", " "),
        Arrays.asList(" ", " ", " ")
    );

    // 更新棋盘上的某个位置
    public void makeMove(int row, int col, String player) {
        if (row >= 0 && row < board.size() && col >= 0 && col < board.get(row).size() && " ".equals(board.get(row).get(col))) {
            board.get(row).set(col, player);
        } else {
            System.out.println("Invalid move at (" + row + "," + col + ")");
        }
    }

    // 打印棋盘
    public void printBoard() {
        for (List row : board) {
            System.out.println(String.join(" | ", row));
            System.out.println("---------");
        }
    }

    // 判断最新落子是否形成胜利组合
    public boolean isWinningMove(int row, int col) {
        // 将NEIGHBOURS数组转换为Stream，并检查是否有任何一个组合满足胜利条件
        return Arrays.stream(NEIGHBOURS)
            .anyMatch(isWinningCombination(row, col));
    }

    // 返回一个谓词，用于检查一个给定的偏移量组是否形成胜利组合
    public Predicate isWinningCombination(int row, int col) {
        return neighbour -> {
            int[] leftShift = neighbour[0];  // 第一个相邻点的偏移量
            int[] rightShift = neighbour[1]; // 第二个相邻点的偏移量
            String currentPlayer = getBoardValue(row, col); // 获取当前落子点的玩家标记

            // 检查当前玩家的棋子是否与两个相邻位置的棋子形成一条线
            return currentPlayer.equals(getBoardValue(row + leftShift[0], col + leftShift[1]))
                && currentPlayer.equals(getBoardValue(row + rightShift[0], col + rightShift[1]));
        };
    }

    // 安全地获取棋盘上的值，处理越界情况
    public String getBoardValue(int row, int col) {
        // 如果索引越界，返回一个不可能与玩家标记匹配的字符串
        if (row < 0 || row >= board.size() || col < 0 || col >= board.get(row).size()) {
            return "INVALID_INDEX"; 
        }
        return board.get(row).get(col); // 返回实际的棋盘值
    }

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

        System.out.println("Initial Board:");
        game.printBoard();

        // 玩家X获胜的例子 (水平线)
        game.makeMove(0, 0, "X"); // X
        game.makeMove(1, 0, "O");
        game.makeMove(0, 1, "X"); // X X
        game.makeMove(2, 1, "O");
        game.makeMove(0, 2, "X"); // X X X

        System.out.println("\nBoard after X wins horizontally:");
        game.printBoard();
        if (game.isWinningMove(0, 2)) {
            System.out.println("Player X wins!");
        }

        // 重置棋盘
        game = new TicTacToe();
        // 玩家O获胜的例子 (垂直线)
        game.makeMove(0, 0, "X");
        game.makeMove(0, 1, "O"); // O
        game.makeMove(1, 1, "X");
        game.makeMove(1, 1, "O"); // O
        game.makeMove(0, 2, "X");
        game.makeMove(2, 1, "O"); // O

        System.out.println("\nBoard after O wins vertically:");
        game.printBoard();
        if (game.isWinningMove(2, 1)) {
            System.out.println("Player O wins!");
        }
    }
}

注意事项与总结

1. 混合式编程的优势： 本文展示了在处理复杂逻辑时，结合命令式编程（如 getBoardValue 中的越界检查和 makeMove 中的状态更新）与函数式编程（如 Stream.anyMatch 和 Predicate）的强大之处。Stream API并非万能，但在合适的场景下能显著提高代码的简洁性和可读性。
2. 效率优化： 只检查最新落子点周围的潜在胜利组合，而非每次都扫描整个棋盘，是游戏逻辑中一个重要的性能优化策略。
3. 可读性： 通过将胜利组合的偏移量抽象为 NEIGHBOURS 数组，并使用 anyMatch 遍历，代码逻辑变得更加清晰，易于理解和维护。
4. 边界处理： getBoardValue 方法中的越界检查和返回“INVALID_INDEX”的策略是健壮性编程的关键，它避免了运行时错误并简化了主逻辑。

通过这种混合式方法，我们不仅能够有效地判断井字棋的胜利条件，还能在保持代码专业性和可读性的同时，充分利用Java Stream API的优势。这种实践对于开发更复杂的棋盘游戏或涉及网格状数据处理的应用程序具有借鉴意义。