井字棋胜负判定教程：修复与优化方法

本文旨在解决井字棋游戏中胜负判定逻辑错误的问题。通过分析代码，找出导致胜负判定失效的原因，并提供修复方案。此外，还将对代码进行优化，使其更加简洁易懂，提升程序的可读性和健壮性。本文将帮助读者理解如何正确实现井字棋游戏的胜负判定功能。

问题分析

原代码中，checkWinner() 函数的胜负判定逻辑存在根本性错误。它使用 plaeyer1position.contains(l) 来判断玩家 1 是否获胜，其中 plaeyer1position 是一个存储玩家 1 落子位置的 ArrayList，而 l 是一个代表获胜组合的 List。

contains() 方法用于判断列表中是否包含指定的对象。由于 plaeyer1position 存储的是 Integer 对象，而 l 是 List 对象，因此 plaeyer1position 永远不会包含 l，导致胜负判定失效。

解决方案

正确的做法是使用 containsAll() 方法，该方法用于判断列表是否包含指定集合中的所有元素。因此，需要将 plaeyer1position.contains(l) 替换为 plaeyer1position.containsAll(l)，同样，plaeyer2position.contains(l) 也要替换为 plaeyer2position.containsAll(l)。

修改后的 checkWinner() 函数如下：

public static String checkWinner(){

    List top_zeile = Arrays.asList(1,2,3);
    List mid_zeile = Arrays.asList(4,5,6);
    List bot_zeile = Arrays.asList(7,8,9);

    List links_reihe = Arrays.asList(1,4,7);
    List mitte_reihe = Arrays.asList(2,5,8);
    List rechts_reihe = Arrays.asList(3,6,9);

    List diagonale_rechts = Arrays.asList(1,5,9);
    List diagonale_links = Arrays.asList(7,5,3);

    List> gewinner = new ArrayList<>();
    gewinner.add(top_zeile);
    gewinner.add(mid_zeile);
    gewinner.add(bot_zeile);
    gewinner.add(links_reihe);
    gewinner.add(mitte_reihe);
    gewinner.add(rechts_reihe);
    gewinner.add(diagonale_links);
    gewinner.add(diagonale_rechts);

    for(List l: gewinner){
        if(plaeyer1position.containsAll(l)){
            return "Spieler 1 gewonnen";
        } else if (plaeyer2position.containsAll(l)) {
            return "Spieler 2 gewonnen";
        }
    }

    if(plaeyer1position.size()+plaeyer2position.size()==9){
        return "Kein Spieler hat gewonnen.\n";
    }

    return "";
}

注意事项：

• 在创建 List 对象时，明确指定泛型类型为 Integer，避免类型转换问题。
• 循环结束后，需要增加一个平局的判断条件，否则在棋盘填满时，可能无法正确判定平局。

代码优化

除了修复胜负判定逻辑错误外，还可以对代码进行一些优化，使其更加简洁易懂。

1. 变量命名： 将变量名改为英文，提高代码的可读性。例如，将 top_zeile 改为 topRow，mid_zeile 改为 midRow，以此类推。

2. 常量定义： 将玩家 1 和玩家 2 的符号定义为常量，方便修改和维护。

   private static final char PLAYER1_SYMBOL = 'X';
   private static final char PLAYER2_SYMBOL = 'O';

3. 简化位置判断逻辑： 可以使用一个二维数组来存储棋盘，并通过计算来确定落子位置。

   public static void determinePosition(char[][] board, int position, String player) {
       char symbol = (player.equals("Player 1")) ? PLAYER1_SYMBOL : PLAYER2_SYMBOL;
       ArrayList playerPositions = (player.equals("Player 1")) ? plaeyer1position : plaeyer2position;
       playerPositions.add(position);
   
       int row = (position - 1) / 3 * 2;
       int col = (position - 1) % 3 * 2;
   
       board[row][col] = symbol;
   }

4. 简化胜负判断逻辑： 可以将所有的获胜组合存储在一个二维数组中，然后遍历该数组进行判断。

   private static final int[][] WINNING_COMBINATIONS = {
           {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, // Rows
           {1, 4, 7}, {2, 5, 8}, {3, 6, 9}, // Columns
           {1, 5, 9}, {3, 5, 7}             // Diagonals
   };
   
   public static String checkWinner() {
       for (int[] combination : WINNING_COMBINATIONS) {
           if (plaeyer1position.containsAll(Arrays.stream(combination).boxed().collect(Collectors.toList()))) {
               return "Player 1 wins!";
           } else if (plaeyer2position.containsAll(Arrays.stream(combination).boxed().collect(Collectors.toList()))) {
               return "Player 2 wins!";
           }
       }
   
       if (plaeyer1position.size() + plaeyer2position.size() == 9) {
           return "It's a draw!";
       }
   
       return "";
   }

完整代码示例

以下是经过修复和优化后的完整代码示例：

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

public class TicTacToe {

    private static final char PLAYER1_SYMBOL = 'X';
    private static final char PLAYER2_SYMBOL = 'O';
    static ArrayList plaeyer1position = new ArrayList<>();
    static ArrayList plaeyer2position = new ArrayList<>();

    private static final int[][] WINNING_COMBINATIONS = {
            {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, // Rows
            {1, 4, 7}, {2, 5, 8}, {3, 6, 9}, // Columns
            {1, 5, 9}, {3, 5, 7}             // Diagonals
    };

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

        printGameBoard(board);

        Scanner scanner = new Scanner(System.in);

        while (true) {
            // Player 1 turn
            System.out.print("Player 1, enter your position (1-9): ");
            int position1 = scanner.nextInt();
            determinePosition(board, position1, "Player 1");
            printGameBoard(board);

            String result = checkWinner();
            if (!result.isEmpty()) {
                System.out.println(result);
                break;
            }

            // Player 2 turn
            System.out.print("Player 2, enter your position (1-9): ");
            int position2 = scanner.nextInt();
            determinePosition(board, position2, "Player 2");
            printGameBoard(board);

            result = checkWinner();
            if (!result.isEmpty()) {
                System.out.println(result);
                break;
            }
        }

        scanner.close();
    }

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

    public static void determinePosition(char[][] board, int position, String player) {
        char symbol = (player.equals("Player 1")) ? PLAYER1_SYMBOL : PLAYER2_SYMBOL;
        ArrayList playerPositions = (player.equals("Player 1")) ? plaeyer1position : plaeyer2position;
        playerPositions.add(position);

        int row = (position - 1) / 3 * 2;
        int col = (position - 1) % 3 * 2;

        board[row][col] = symbol;
    }

    public static String checkWinner() {
        for (int[] combination : WINNING_COMBINATIONS) {
            if (plaeyer1position.containsAll(Arrays.stream(combination).boxed().collect(Collectors.toList()))) {
                return "Player 1 wins!";
            } else if (plaeyer2position.containsAll(Arrays.stream(combination).boxed().collect(Collectors.toList()))) {
                return "Player 2 wins!";
            }
        }

        if (plaeyer1position.size() + plaeyer2position.size() == 9) {
            return "It's a draw!";
        }

        return "";
    }
}

总结

本文详细分析了井字棋游戏中胜负判定逻辑错误的原因，并提供了修复方案。通过使用 containsAll() 方法，可以正确判断玩家是否获胜。此外，还对代码进行了优化，使其更加简洁易懂，提高了代码的可读性和可维护性。希望本文能够帮助读者更好地理解井字棋游戏的实现原理，并能够编写出更加健壮和高效的代码。