Java 2D 数组操作：优化方法以直接返回新元素位置坐标

public static int[][] putNumber(int[][] board, String columnInput, int randomNumber) {
    // ... 放置数字的逻辑 ...
    return board; // 返回整个修改后的数组
}

1 2 2 1 3 2
3 3 2 2 1 3
3 2 2 3 3 1
2 3 2 1 2 3
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

1 2 2 1 3 2
3 3 2 2 1 3
3 2 2 3 3 1
2 3 2 1 2 3
0 2 0 0 0 0  <- 新放置的 '2'
0 0 0 0 0 0
0 0 0 0 0 0

int[][] board1 = new int[7][6];
// ... 初始化 board1 ...

// 调用 putNumber 方法，board1 的内容将被修改
putNumber(board1, "B", 2);

// 此时，board1 已经包含了新放置的数字，即使 putNumber 返回的是 void 或其他类型
System.out.println(Arrays.deepToString(board1));

import java.util.Arrays; // 导入 Arrays 工具类以便打印数组

public class BoardOperations {

    /**
     * 将一个数字放置到指定列的第一个空位 (0) 中，并返回其放置位置的坐标。
     *
     * @param board      二维数组表示的棋盘。
     * @param columnInput 用户输入的列字母 (A-F)。
     * @param randomNumber 要放置的数字。
     * @return 包含新放置数字的 [行, 列] 坐标的 int 数组；如果列已满或输入无效，则返回 [-1, -1]。
     */
    public static int[] putNumber(int[][] board, String columnInput, int randomNumber) {
        // 将列字母转换为对应的整数索引
        // 'A' 的 ASCII 码减去 'A' 的 ASCII 码得到 0
        // 'B' 的 ASCII 码减去 'A' 的 ASCII 码得到 1，以此类推
        int columnIndex = -1;
        if (columnInput != null && !columnInput.isEmpty()) {
            char colChar = Character.toUpperCase(columnInput.charAt(0));
            if (colChar >= 'A' && colChar <= 'A' + board[0].length - 1) { // 确保列字母在有效范围内
                columnIndex = colChar - 'A';
            }
        }

        if (columnIndex == -1) {
            System.err.println("错误：无效的列输入或列索引超出范围。");
            return new int[]{-1, -1}; // 返回特殊值表示错误
        }

        int saveRow = -1; // 用于存储放置数字的行索引

        // 遍历指定列，找到第一个值为 0 的位置
        for (int row = 0; row < board.length; row++) {
            if (board[row][columnIndex] == 0) {
                board[row][columnIndex] = randomNumber; // 放置数字
                saveRow = row; // 记录行索引
                break; // 找到并放置后即可退出循环
            }
        }

        // 返回新放置数字的 [行, 列] 坐标
        // 如果 saveRow 仍为 -1，表示该列已满
        return new int[]{saveRow, columnIndex};
    }

    // 辅助方法：打印棋盘
    public static void printBoard(int[][] board) {
        for (int[] row : board) {
            for (int cell : row) {
                System.out.print(cell + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int[][] board = {
            {1, 2, 2, 1, 3, 2},
            {3, 3, 2, 2, 1, 3},
            {3, 2, 2, 3, 3, 1},
            {2, 3, 2, 1, 2, 3},
            {0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0}
        };

        System.out.println("--- 原始棋盘 ---");
        printBoard(board);

        // 示例 1: 在 'B' 列放置数字 2
        int[] location1 = putNumber(board, "B", 2);
        if (location1[0] != -1) {
            System.out.println("\n--- 放置数字 2 (B 列) 后的棋盘 ---");
            printBoard(board);
            System.out.println("新放置数字 2 的位置: 行 " + location1[0] + ", 列 " + location1[1]);
        } else {
            System.out.println("\nB 列已满或输入无效，无法放置数字。");
        }

        // 示例 2: 在 'D' 列放置数字 1
        int[] location2 = putNumber(board, "D", 1);
        if (location2[0] != -1) {
            System.out.println("\n--- 放置数字 1 (D 列) 后的棋盘 ---");
            printBoard(board);
            System.out.println("新放置数字 1 的位置: 行 " + location2[0] + ", 列 " + location2[1]);
        } else {
            System.out.println("\nD 列已满或输入无效，无法放置数字。");
        }

        // 示例 3: 尝试放置到已满的列 (假设 B 列已满)
        // 为了演示，我们先填充 B 列
        for (int i = 0; i < 3; i++) { // 填充 B 列的剩余空位
             putNumber(board, "B", 9);
        }
        System.out.println("\n--- 填充 B 列后的棋盘 ---");
        printBoard(board);

        int[] location3 = putNumber(board, "B", 5); // 尝试放置到已满的 B 列
        if (location3[0] != -1) {
            System.out.println("\n--- 放置数字 5 (B 列) 后的棋盘 ---");
            printBoard(board);
            System.out.println("新放置数字 5 的位置: 行 " + location3[0] + ", 列 " + location3[1]);
        } else {
            System.out.println("\nB 列已满或输入无效，无法放置数字 5。");
        }
    }
}