在井字棋等复杂游戏逻辑中，单纯依赖java streams实现完整的胜利条件判断具有挑战性，尤其是当条件涉及空间排列时。本文将探讨如何将stream的函数式特性与必要的命令式逻辑相结合，以高效地检查井字棋的获胜条件。我们将重点介绍如何利用`stream.anymatch()`来判断最后一步棋是否形成了水平、垂直或对角线上的获胜组合，通过定义邻居偏移量来简化空间检查，从而实现一种既清晰又实用的解决方案。
Java Streams处理复杂游戏逻辑的挑战
井字棋（Tic-Tac-Toe）的获胜条件并非简单地检查棋盘上是否有三个相同的棋子。它要求这三个相同的棋子必须形成一条直线，包括水平、垂直或对角线。最初的尝试可能倾向于使用Java Streams来统计棋盘上特定棋子的出现次数，但这并不能反映其空间排列关系，因此无法正确判断游戏胜负。
纯粹使用Java Streams来处理这种复杂的、依赖于空间位置和多条件判断的逻辑是困难的，甚至是不切实际的。Streams更擅长于数据的转换、过滤和聚合，而对于需要迭代检查多个方向、并进行多级条件判断的场景，直接的Stream操作往往会导致代码复杂性剧增或性能下降。然而，这并不意味着Streams完全无用，我们可以巧妙地将其与传统的命令式编程结合，以实现更优雅和高效的解决方案。
核心策略：结合函数式与命令式编程
解决井字棋获胜条件判断的关键在于，我们无需检查整个棋盘上所有可能的获胜组合。实际上，只需要在玩家下完最后一步棋后，检查以这颗新下的棋子为中心，它所能形成的所有潜在获胜线。这种局部检查的思路极大地简化了问题。
我们可以将检查过程分解为以下几步：
立即学习“Java免费学习笔记（深入）”；
- 识别潜在获胜方向： 定义棋子可能形成获胜线的四个基本方向：水平、垂直、主对角线和副对角线。
- 定位相邻棋子： 对于每个方向，确定新下的棋子两侧的两个单元格。
- 判断一致性： 检查新下的棋子及其两侧的两个单元格是否都属于同一玩家。
在这个过程中，Stream.anyMatch()方法能够发挥其函数式编程的优势。我们可以定义一个包含所有潜在方向的集合，然后使用anyMatch()来判断是否存在至少一个方向满足获胜条件。
实现细节：定义获胜组合与棋盘表示
为了有效地表示和检查获胜组合，我们可以使用一个静态的三维数组来存储每个方向上，一个棋子两侧的相对偏移量。
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> 表示，方便修改单元格内容
private List> 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;
// ... 后续方法 ...
} 棋盘表示说明：
- board 变量使用 List
- > 来表示棋盘，其中内部的 ArrayList 允许修改单元格的值（例如，将 "1" 替换为 "X" 或 "O"）。
- 初始化时可以填充任意非空值，以便后续进行 equals() 比较。在实际游戏中，这些值会被玩家的标记（如 "X" 或 "O"）替换。
核心方法：判断是否获胜
以下是实现获胜条件判断的核心方法：
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> 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 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 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 (没有形成直线)
}
} 注意事项与最佳实践
- 函数式与命令式的平衡： 此解决方案并非“纯粹”的Stream-only，而是巧妙地将Stream.anyMatch()的声明性风格与Predicate内部的命令式逻辑（如边界检查和值比较）相结合。这种混合范式在处理复杂业务逻辑时往往更实用。
- 边界条件处理： getBoardValue 方法中的边界检查至关重要。它确保了即使在棋盘边缘下棋，也不会因为访问越界索引而导致程序崩溃。返回“INVALID INDEX”字符串是一种有效的策略，因为它是一个不可能与玩家标记（如“X”或“O”）匹配的值，从而自然地使isWinningCombination返回false。
-
棋盘表示： 示例中使用了 List
- >。对于固定大小的棋盘，使用 String[][] 二维数组可能更直观和高效，因为它避免了 List 的额外开销，并且索引访问更快。然而，List 提供了更大的灵活性。
- 性能考虑： 这种方法只检查最后一步棋周围的少量单元格，而不是遍历整个棋盘或所有可能的组合，因此效率很高。
- 可读性： 通过将方向偏移量抽象到 NEIGHBOURS 数组中，并使用 Predicate 封装单个方向的检查逻辑，代码变得更加模块化和易于理解。
总结
尽管Java Streams在数据处理方面表现出色，但在处理像井字棋获胜条件这样涉及复杂空间关系和多级条件判断的场景时，纯粹的Stream-only方案往往力不从心。本文展示了一种实用而高效的方法：通过结合Stream.anyMatch()的函数式风格与必要的命令式逻辑，我们能够清晰、准确地判断井字棋的获胜条件。这种方法不仅解决了问题，还体现了在实际开发中，灵活运用不同编程范式来平衡代码的简洁性、可读性和性能的重要性。
