基于Java Streams辅助实现井字棋胜利条件判断-java教程-PHP中文网

基于Java Streams辅助实现井字棋胜利条件判断

本文探讨了在java井字棋游戏中，如何利用java streams辅助判断胜利条件，并分析了纯粹使用streams实现此类复杂逻辑的局限性。文章将展示一种结合部分函数式编程思想与必要命令式逻辑的解决方案，通过定义邻居偏移量和使用`stream.anymatch()`高效检查最新落子是否形成赢局，从而提供一种实用且结构清晰的实现方法。

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

井字棋（Tic-Tac-Toe）的胜利条件并非简单地统计某个玩家棋子的数量，而是要求特定数量的棋子（通常是三个）在棋盘上形成一条直线，包括水平、垂直或对角线。这涉及到对棋盘二维空间中元素位置关系的判断。

原始问题中提出的解决方案，例如使用Collections.frequency()或Collectors.groupingBy()来统计元素出现次数，虽然能够找出重复的元素，但无法识别这些元素是否在空间上构成了一个有效的赢局。例如，即使棋盘上有三个“X”，如果它们分散在不同位置，也无法构成胜利。因此，纯粹依赖Java Streams进行通用数据流处理的特性，来直接判断这种复杂的空间关系，是极具挑战的，甚至在某些情况下是不切实际的。Streams主要设计用于数据的转换、过滤、映射和聚合，而非处理复杂的、依赖于多步上下文的二维空间逻辑。

结合函数式与命令式编程的策略

鉴于井字棋胜利条件判断的复杂性，完全使用Java Streams实现所有逻辑是困难的。一种更实际且高效的方法是结合函数式编程的某些优点（如使用Stream.anyMatch()进行条件匹配）与必要的命令式逻辑来管理棋盘状态和复杂的空间判断。

核心策略在于：我们不需要在每次落子后检查整个棋盘上的所有可能赢局组合。相反，只需要检查与最新落子相邻的、可能形成赢局的线条。这种局部检查大大减少了计算量，并简化了逻辑。

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

为了实现这一策略，我们需要定义一组“邻居偏移量”，这些偏移量代表了从当前落子位置出发，可以形成水平、垂直或对角线赢局的两个方向。

实现胜利条件判断

我们将通过一个TicTacToe类来演示如何实现这一逻辑。

1. 棋盘表示

棋盘可以使用List<List<String>>来表示，其中每个内部列表代表一行或一列（取决于实现偏好），String类型的值代表棋子（例如“X”、“O”或空位）。为了方便示例，我们假设棋盘是3x3的。

MagicStudio

图片处理必备效率神器！为你的图片提供神奇魔法

102

查看详情

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

public class TicTacToe {
    // 棋盘表示，使用Arrays.asList()以便可以修改内部元素值
    private List<List<String>> board = List.of(
        Arrays.asList("1", "4", "7"), // 初始填充非null值，以便安全进行equals()检查
        Arrays.asList("2", "5", "8"),
        Arrays.asList("3", "6", "9")
    );
    // ... 其他方法
}

登录后复制

2. 邻居偏移量定义

定义一个静态的三维数组NEIGHBOURS，用于存储所有可能形成赢局的两个方向的偏移量。每个内部的int[][]代表一个潜在的赢局方向（例如水平、垂直、两种对角线），而int[]则表示从当前落子点到该方向上两个邻居的行和列偏移量。

public class TicTacToe {
    // ... board 定义

    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}}是重复的，都代表主对角线。这里将其修正为代表另一条对角线（副对角线）。

3. isWinningMove方法

这是判断最新落子是否形成赢局的入口方法。它利用Arrays.stream(NEIGHBOURS)将所有潜在的赢局方向转换为一个流，然后使用anyMatch()来检查是否存在至少一个方向满足赢局条件。

public class TicTacToe {
    // ... NEIGHBOURS 和 board 定义

    /**
     * 判断给定坐标的最新落子是否形成赢局。
     * @param row 落子的行坐标
     * @param col 落子的列坐标
     * @return 如果形成赢局则返回 true，否则返回 false。
     */
    public boolean isWinningMove(int row, int col) {
        return Arrays.stream(NEIGHBOURS)
            .anyMatch(isWinningCombination(row, col));
    }

    // ... 其他方法
}

登录后复制

4. isWinningCombination谓词

这个方法返回一个Predicate<int[][]>，它封装了检查特定方向是否形成赢局的逻辑。Predicate会接收NEIGHBOURS数组中的一个int[][]元素（即一对偏移量），然后根据这些偏移量检查当前玩家在row, col位置及其两个邻居是否都相同。

public class TicTacToe {
    // ... NEIGHBOURS 和 board 定义

    /**
     * 创建一个谓词，用于检查给定方向（邻居偏移量）是否形成赢局。
     * @param row 当前落子的行坐标
     * @param col 当前落子的列坐标
     * @return 一个Predicate，用于判断传入的邻居偏移量是否构成赢局。
     */
    public Predicate<int[][]> isWinningCombination(int row, int col) {
        return neighbourOffsets -> {
            int[] leftShift = neighbourOffsets[0];  // 第一个邻居的偏移量
            int[] rightShift = neighbourOffsets[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);
        };
    }

    // ... 其他方法
}

登录后复制

5. getBoardValue辅助方法

为了安全地访问棋盘上的值并处理越界情况，我们需要一个辅助方法。如果请求的坐标超出棋盘范围，它将返回一个特殊值（例如“INVALID INDEX”），确保isWinningCombination中的equals()比较不会因为null或越界而抛出异常，并且能正确地判断为非赢局。

public class TicTacToe {
    // ... NEIGHBOURS 和 board 定义

    /**
     * 安全地获取棋盘上指定坐标的值。
     * @param row 行坐标
     * @param col 列坐标
     * @return 棋盘上的值，如果坐标越界则返回 "INVALID INDEX"。
     */
    public String getBoardValue(int row, int col) {
        if (row < 0 || row >= board.size() || col < 0 || col >= board.get(row).size()) {
            return "INVALID INDEX"; // 返回一个非法值，确保isWinningCombination()会返回false
        }
        return board.get(row).get(col); // 返回真实值
    }

    // ... 其他方法
}

登录后复制

完整示例代码

将上述所有组件整合到一个TicTacToe类中，形成一个完整的示例。

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

public class TicTacToe {

    // 定义所有可能的赢局方向的邻居偏移量
    // 每个内部数组包含两个偏移量：[行偏移, 列偏移]
    // 例如：{{0, -1}, {0, 1}} 表示水平方向，从当前点向左和向右各一个单位
    public static final int[][][] NEIGHBOURS = {
           {{0, -1}, {0, 1}},   // 水平方向
            {{-1, 0}, {1, 0}},   // 垂直方向
            {{-1, -1}, {1, 1}},  // 主对角线
            {{1, -1}, {-1, 1}}   // 副对角线
    };

    // 棋盘表示，使用List<List<String>>。
    // Arrays.asList() 创建的列表是固定大小但元素可修改的。
    // 初始填充非null值，以便进行equals()检查。
    private List<List<String>> board = List.of(
        Arrays.asList("1", "4", "7"),
        Arrays.asList("2", "5", "8"),
        Arrays.asList("3", "6", "9")
    );

    /**
     * 设置棋盘上指定位置的值。
     * @param row 行坐标
     * @param col 列坐标
     * @param value 要设置的值（例如 "X" 或 "O"）
     */
    public void setBoardValue(int row, int col, String value) {
        if (row >= 0 && row < board.size() && col >= 0 && col < board.get(row).size()) {
            board.get(row).set(col, value);
        } else {
            System.err.println("尝试在非法位置 (" + row + ", " + col + ") 落子。");
        }
    }

    /**
     * 判断给定坐标的最新落子是否形成赢局。
     * 该方法利用Stream.anyMatch()检查所有预定义的邻居组合。
     * @param row 落子的行坐标
     * @param col 落子的列坐标
     * @return 如果形成赢局则返回 true，否则返回 false。
     */
    public boolean isWinningMove(int row, int col) {
        // 将所有邻居组合转换为Stream，并检查是否有任何一个组合构成赢局
        return Arrays.stream(NEIGHBOURS)
            .anyMatch(isWinningCombination(row, col));
    }

    /**
     * 创建一个谓词，用于检查给定方向（邻居偏移量）是否形成赢局。
     * 谓词会检查当前玩家的棋子是否与该方向上的两个邻居棋子相同。
     * @param row 当前落子的行坐标
     * @param col 当前落子的列坐标
     * @return 一个Predicate，用于判断传入的邻居偏移量是否构成赢局。
     */
    public Predicate<int[][]> isWinningCombination(int row, int col) {
        return neighbourOffsets -> {
            int[] leftShift = neighbourOffsets[0];  // 第一个邻居的偏移量
            int[] rightShift = neighbourOffsets[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]));
        };
    }

    /**
     * 安全地获取棋盘上指定坐标的值。
     * 如果坐标越界，则返回一个特殊字符串 "INVALID INDEX"，
     * 这样可以避免NullPointerException，并确保isWinningCombination()不会误判越界情况为赢局。
     * @param row 行坐标
     * @param col 列坐标
     * @return 棋盘上的值，如果坐标越界则返回 "INVALID INDEX"。
     */
    public String getBoardValue(int row, int col) {
        if (row < 0 || row >= board.size() || col < 0 || col >= board.get(row).size()) {
            return "INVALID INDEX"; // 返回一个非法值，确保isWinningCombination()会返回false
        }
        return board.get(row).get(col); // 返回真实值
    }

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

    public static void main(String[] args) {
        TicTacToe game = new TicTacToe();
        System.out.println("初始棋盘:");
        game.printBoard();

        // 玩家X落子，形成水平赢局
        System.out.println("\n玩家X落子 (0,0), (0,1), (0,2)");
        game.setBoardValue(0, 0, "X");
        game.setBoardValue(0, 1, "X");
        game.setBoardValue(0, 2, "X");
        game.printBoard();
        System.out.println("玩家X在 (0,2) 落子后是否赢了? " + game.isWinningMove(0, 2)); // 应该为true

        // 重置棋盘（简化操作，实际游戏中需要更完善的重置逻辑）
        game = new TicTacToe(); 
        game.setBoardValue(1, 1, "O"); // 中心
        game.setBoardValue(0, 0, "O"); // 左上
        System.out.println("\n玩家O落子 (2,2) 形成对角线赢局");
        game.setBoardValue(2, 2, "O"); // 右下
        game.printBoard();
        System.out.println("玩家O在 (2,2) 落子后是否赢了? " + game.isWinningMove(2, 2)); // 应该为true

        // 重置棋盘
        game = new TicTacToe(); 
        game.setBoardValue(0, 0, "X");
        game.setBoardValue(1, 0, "X");
        game.setBoardValue(2, 1, "X"); // 不构成赢局
        System.out.println("\n玩家X落子 (2,1) 不构成赢局");
        game.printBoard();
        System.out.println("玩家X在 (2,1) 落子后是否赢了? " + game.isWinningMove(2, 1)); // 应该为false
    }
}

登录后复制

注意事项与总结

Stream的局限性：此示例清晰地展示了Java Streams在处理井字棋这类具有复杂空间和上下文依赖逻辑时的局限性。Streams更擅长于对数据集合进行声明式转换和聚合操作，而非复杂的条件分支或多维空间关系判断。尝试用纯粹的Stream来实现所有逻辑往往会导致代码晦涩、效率低下，甚至是不可能的。
混合编程范式：在实际开发中，结合不同编程范式（如函数式和命令式）的优点是一种常见的有效策略。本教程的解决方案就是一个很好的例子：它利用了Stream.anyMatch()的函数式风格来优雅地遍历和匹配赢局条件，但底层判断（isWinningCombination谓词内部）仍然依赖于命令式逻辑来访问和比较棋盘上的具体元素。
性能考量：通过只检查最新落子周围的潜在赢局，而不是每次都扫描整个棋盘，大大提高了判断效率。这是一种常见的优化策略，适用于许多棋类游戏。
可读性和维护性：尽管包含了一些命令式代码，但通过将不同职责（如棋盘访问、赢局方向定义、具体赢局判断）封装在不同的方法中，代码的结构依然清晰，易于理解和维护。NEIGHBOURS数组的定义使得添加或修改赢局规则变得相对简单。

总之，虽然Java Streams本身无法独立完成井字棋胜利条件的所有复杂判断，但它可以作为强大的辅助工具，通过结合适量的命令式逻辑，帮助我们以更简洁、声明式的方式实现部分核心功能，从而构建出既高效又易于理解的游戏逻辑。

以上就是基于Java Streams辅助实现井字棋胜利条件判断的详细内容，更多请关注php中文网其它相关文章！