TicTacToe游戏checkWinner函数无胜负判定输出问题排查求助

错误原因分析 #

你的代码无法输出胜负结果，核心问题出在checkWinner函数的判断逻辑上：

• 使用plaeyer1position.contains(l)是判断玩家位置集合是否包含整个获胜列表对象，而非判断玩家是否拥有该获胜组合的所有位置。正确的做法是用containsAll方法，检查玩家集合是否包含获胜组合里的全部元素。
• 平局判断放在了循环内部的else if分支，导致只要第一个获胜组合不匹配，就会直接返回平局，逻辑顺序错误。
• 额外问题：Scanner在循环内重复创建、未处理重复位置输入、玩家回合后未即时检查胜负。

修正后的完整代码 #

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class TicTacToe {

    static ArrayList<Integer> player1Position = new ArrayList<>();
    static ArrayList<Integer> player2Position = new ArrayList<>();

    public static void main(String[] args) {
        char[][] board = {
                {' ', '|', ' ', '|', ' '},
                {'-', '+', '-', '+', '-'},
                {' ', '|', ' ', '|', ' '},
                {'-', '+', '-', '+', '-'},
                {' ', '|', ' ', '|', ' '}
        };

        gameBoard(board);
        Scanner scn = new Scanner(System.in);

        while (true) {
            // 玩家1回合
            int position = getValidPosition(scn, board);
            setPosition(board, position, "Spieler 1");
            gameBoard(board);
            String result = checkWinner();
            if (!result.isEmpty()) {
                System.out.println(result);
                break;
            }

            // 玩家2回合
            position = getValidPosition(scn, board);
            setPosition(board, position, "Spieler 2");
            gameBoard(board);
            result = checkWinner();
            if (!result.isEmpty()) {
                System.out.println(result);
                break;
            }
        }
        scn.close();
    }

    public static void gameBoard(char[][] board) {
        for (char[] row : board) {
            for (char c : row) {
                System.out.print(c);
            }
            System.out.println();
        }
    }

    // 获取合法的位置输入（避免重复选择）
    public static int getValidPosition(Scanner scn, char[][] board) {
        int position;
        while (true) {
            System.out.println("Geben Sie die Position ein (1-9):");
            position = scn.nextInt();
            // 检查位置是否已被占用
            if (player1Position.contains(position) || player2Position.contains(position)) {
                System.out.println("Diese Position ist bereits belegt! Wählen Sie eine andere.");
            } else if (position < 1 || position > 9) {
                System.out.println("Ungültige Position! Geben Sie eine Zahl zwischen 1 und 9 ein.");
            } else {
                break;
            }
        }
        return position;
    }

    public static void setPosition(char[][] board, int position, String spieler) {
        char symbol = ' ';

        if (spieler.equals("Spieler 1")) {
            symbol = 'X';
            player1Position.add(position);
        } else if (spieler.equals("Spieler 2")) {
            symbol = 'O';
            player2Position.add(position);
        }

        switch (position) {
            case 1:
                board[0][0] = symbol;
                break;
            case 2:
                board[0][2] = symbol;
                break;
            case 3:
                board[0][4] = symbol;
                break;
            case 4:
                board[2][0] = symbol;
                break;
            case 5:
                board[2][2] = symbol;
                break;
            case 6:
                board[2][4] = symbol;
                break;
            case 7:
                board[4][0] = symbol;
                break;
            case 8:
                board[4][2] = symbol;
                break;
            case 9:
                board[4][4] = symbol;
                break;
            default:
                break;
        }
    }

    public static String checkWinner() {
        List<Integer> topRow = Arrays.asList(1, 2, 3);
        List<Integer> midRow = Arrays.asList(4, 5, 6);
        List<Integer> botRow = Arrays.asList(7, 8, 9);

        List<Integer> leftCol = Arrays.asList(1, 4, 7);
        List<Integer> midCol = Arrays.asList(2, 5, 8);
        List<Integer> rightCol = Arrays.asList(3, 6, 9);

        List<Integer> diagRight = Arrays.asList(1, 5, 9);
        List<Integer> diagLeft = Arrays.asList(7, 5, 3);

        List<List<Integer>> winningCombos = new ArrayList<>();
        winningCombos.add(topRow);
        winningCombos.add(midRow);
        winningCombos.add(botRow);
        winningCombos.add(leftCol);
        winningCombos.add(midCol);
        winningCombos.add(rightCol);
        winningCombos.add(diagLeft);
        winningCombos.add(diagRight);

        for (List<Integer> combo : winningCombos) {
            if (player1Position.containsAll(combo)) {
                return "Spieler 1 gewonnen!";
            } else if (player2Position.containsAll(combo)) {
                return "Spieler 2 gewonnen!";
            }
        }

        // 遍历完所有组合后再检查平局
        if (player1Position.size() + player2Position.size() == 9) {
            return "Kein Spieler hat gewonnen. Unentschieden!";
        }

        return "";
    }
}

关键修改说明 #

1. 胜负判断逻辑修正：将contains(l)改为containsAll(combo)，正确检查玩家是否拥有获胜组合的全部位置。
2. 平局判断位置调整：将平局判断移到所有获胜组合遍历完成后，避免提前误判。
3. 输入合法性检查：新增getValidPosition方法，防止玩家选择已被占用或超出范围的位置。
4. 即时胜负检查：每个玩家走完一步后立即检查胜负，若分出胜负则终止游戏。
5. 代码优化：修正变量拼写错误（plaeyer改为player），将Scanner移到循环外并最终关闭，避免资源浪费。

内容的提问来源于stack exchange，提问作者Bogdan Klinowitzki