用Java实现五子棋对弈

高手敏smart_sheep

已于 2022-11-24 01:07:07 修改

阅读量1k

点赞数 3

文章标签： java 开发语言

于 2022-11-24 01:06:45 首次发布

本文链接：https://blog.csdn.net/W2810741612/article/details/127945552

版权

题目展示

1.使用二维数组存储五子棋棋盘

如下图

2.在控制台通过Scanner输入黑白棋坐标( 表示二维数组坐标),使用实心五角星和空心五角星表示黑白棋子。

如下图:

输入后重新输出棋盘如下图:

白棋输入后如下图：

黑白棋依次重复输入下棋。

3.每下一个棋子后需要判断该棋子是否出界,此位置是否已经有棋子,判断是否有5个棋子连在一起,有则表示胜利,否则继续下棋。

题目分析

1.输出棋盘（重复使用）方法

（1）棋盘是15行15列的，先创建容量为[15][15]的二维数组，素材与数组的创建如下：

static String white = "☆";
    static String black = "★";
    static String[][] qp = new String[15][15];
    static String[] num = {"⒈", "⒉", "⒊", "⒋", "⒌", "⒍", "⒎", "⒏", "⒐", "⒑", "⒒", "⒓", "⒔", "⒕", "⒖"};
    static String line = "十";

（2）对数组进行初始化，将默认的null替换为"十"，再将最后一行和最后一列进行替换；创建了initQP方法，用两层循环，取出二维数组里的每一个元素，判断是否为最后一行和最后一列，如果是，则用num数组进行替换：

public static void initQP() {
        for (int i = 0; i < qp.length; i++) {
            for (int j = 0; j < qp[i].length; j++) {//取出每一个元素
                if (i == qp.length - 1) {//判断是否为最后一行元素
                    qp[i][j] = num[j];//令最后一行第一位为num数组里的第一位......
                } else if (j == qp.length - 1) {//判断是否为最后一列元素
                    qp[i][j] = num[i];//令最后一列第一位为num数组里的第一位......
                } else {//如果不是最后一列
                    qp[i][j] = line;//将null替换为line中的"十"
                }
            }
        }
    }

（3）初始化棋盘已经完成，现在进行打印棋盘；注意：二维数组不能用Arrays.toString()输出，不能输出里层数组的值，只能通过数组的遍历进行输出，注意换行：

    public static void printQP() {//二维数组不能用Arrays.toString()输出，不能输出里层数组的值，通过遍历进行输出；
        for (int i = 0; i < qp.length; i++) {
            for (int j = 0; j < qp[i].length; j++) {
                System.out.print(qp[i][j]);
            }
            System.out.println("");//一行输出完了，进行换行；
        }
    }

2.开始下棋，判断黑白双方谁下棋，进行交替下棋，基本判断：棋子是否越界，棋子是否重复

（1）五子棋黑棋先落子，用户输入落子位置，判断是否有效，无效则需重新落子，有效则判断输赢，未获胜，则轮到白棋落子，进行循环，直至一方获胜；注：索引从0开始，故输入值均减一，在这里创建了check方法，来检查棋子是否有效，有效则返回true，替换上黑棋，打印棋盘，判断输赢，同样，创建iswin方法，未获胜，则令p=false，进入白棋落子,这里的y代表行数，x代表列数；

 static boolean p = true;
.
.
.
while (true) {
            if (p) {
                System.out.println("请黑子下子：");
                int y = sc.nextInt() - 1;
                int x = sc.nextInt() - 1;
                Boolean t = Demo7.check(x, y);//检查x,y是否有效
                if (t) {//有效
                    qp[y][x] = black;
                    printQP();
                    //判断输赢
                    Boolean w=iswin(y, x, black);
                    if(w){
                        System.out.println("黑棋获胜！");
                        break;
                    }
                    else{
                        p = false;//进入白棋下子
                    }
                } else {
                    System.out.println("无效棋！请重新下子！");
                }
            }
            else {
                System.out.println("请白子下子：");
                int y = sc.nextInt() - 1;
                int x = sc.nextInt() - 1;
                Boolean t = Demo7.check(x, y);
                if (t) {
                    qp[y][x] = white;
                    printQP();
                    //判断输赢
                    Boolean w=iswin(y, x, white);
                    if(w){
                        System.out.println("白棋获胜！");
                        break;
                    }
                    else{
                        p = true;//有效则进入下一轮
                    }
                }
                else {
                    System.out.println("无效棋！请重新下子！");
                }
            }
        }
    }

（2）判断棋子是否有效，主要从两个方面：是否出界，是否下过棋子（判断该点元素是否为"十"），equals判断两数组元素是否相同，相同返回true；

    public static boolean check(int x, int y) {
        if (x < 0 || x > qp.length - 1 || y < 0 || y > qp.length - 1) {//判断是否超出边界
            return false;
        }
        if (!qp[y][x].equals(line)) {//判断位置是否下过棋子
            return false;
        }
        return true;
    }

3.判断输赢

（1）每下一个棋子都要判断输赢，以当前下的棋子为中心，以水平为例，设定一个水平计数器，int spsum=1，先向左找，知道第0列，spsum>=5，如果不够，则继续向右找，直至<length-1

int spsum=1;//水平计数器
        for(int lx=x-1;lx>=0;lx--){//水平向左查找
            if(qp[y][lx].equals(qz)){
                spsum++;
            }else{
                break;
            }
            if(spsum>=5){
                return true;
            }
        }
        for(int rx=x+1;rx<qp.length-1;rx++){//水平向右查找
            if(qp[y][rx].equals(qz)){
                spsum++;
            }else{
                break;
            }
            if(spsum>=5){
                return true;
            }
        }

（2）竖直找与水平找相似

int szsum=1;//竖直计数器
        for(int ny=y-1;ny>=0;ny--){//竖直向上查找
            if(qp[ny][x].equals(qz)){
                szsum++;
            }else{
                break;
            }
            if(szsum>=5){
                return true;
            }
        }
        for(int sy=y+1;sy<qp.length-1;sy++){//数值向下查找
            if(qp[sy][x].equals(qz)){
                szsum++;
            }else{
                break;
            }
            if(szsum>=5){
                return true;
            }
        }

（3）斜着查找两个都在变

int lsum=1;//左对角计数器
        for(int lnx=x-1,lny=y-1;lnx>=0&&lny>=0;lnx--,lny--){//左斜向上查找
            if(qp[lny][lnx].equals(qz)){
                lsum++;
            }else{
                break;
            }
            if(lsum>=5){
                return true;
            }
        }
        for(int lsx=x+1,lsy=y+1;lsx<qp.length-1&&lsy<qp.length-1;lsx++,lsy++){//左斜向下查找
            if(qp[lsy][lsx].equals(qz)){
                lsum++;
            }else{
                break;
            }
            if(lsum>=5){
                return true;
            }
        }
        int rsum=1;//右对角计数器
        for(int rnx=x+1,rny=y-1;rnx<qp.length-1&&rny>=0;rnx++,rny--){//右斜向上查找
            if(qp[rny][rnx].equals(qz)){
                rsum++;
            }else{
                break;
            }
            if(rsum>=5){
                return true;
            }
        }
        for(int rsx=x-1,rsy=y+1;rsy<qp.length-1&&rsx>=0;rsy++,rsx--){//右斜向下查找
            if(qp[rsy][rsx].equals(qz)){
                rsum++;
            }else{
                break;
            }
            if(rsum>=5){
                return true;
            }
        }
        return false;
    }

代码实现

在主函数里使用各个方法，最终代码如下：

import java.util.Scanner;
public class Demo7 {
    static String white = "☆";
    static String black = "★";
    static String[][] qp = new String[15][15];
    static String[] num = {"⒈", "⒉", "⒊", "⒋", "⒌", "⒍", "⒎", "⒏", "⒐", "⒑", "⒒", "⒓", "⒔", "⒕", "⒖"};
    static String line = "十";
    static Scanner sc = new Scanner(System.in);
    static boolean p = true;

    //[0,14] ...[13,14]...[14][0]......[14][14]
    //14*14
    public static void main(String[] args) {
        Demo7.initQP();
        Demo7.printQP();
        Demo7.star();
    }

    //初始棋盘
    public static void initQP() {
        for (int i = 0; i < qp.length; i++) {
            for (int j = 0; j < qp[i].length; j++) {//取出每一个元素
                if (i == qp.length - 1) {//判断是否为最后一行元素
                    qp[i][j] = num[j];//令最后一行第一位为num数组里的第一位......
                } else if (j == qp.length - 1) {//判断是否为最后一列元素
                    qp[i][j] = num[i];//令最后一列第一位为num数组里的第一位......
                } else {//如果不是最后一列
                    qp[i][j] = line;//将null替换为line中的"十"
                }
            }
        }
    }

    //打印棋盘
    public static void printQP() {//二维数组不能用Arrays.toString()输出，不能输出里层数组的值，通过遍历进行输出；
        for (int i = 0; i < qp.length; i++) {
            for (int j = 0; j < qp[i].length; j++) {
                System.out.print(qp[i][j]);
            }
            System.out.println("");//一行输出完了，进行换行；
        }
    }

    //开始下棋
    public static void star() {
        while (true) {
            if (p) {
                System.out.println("请黑子下子：");
                int y = sc.nextInt() - 1;
                int x = sc.nextInt() - 1;
                Boolean t = Demo7.check(x, y);//检查x,y是否有效
                if (t) {//有效
                    qp[y][x] = black;
                    printQP();
                    //判断输赢
                    Boolean w=iswin(y, x, black);
                    if(w){
                        System.out.println("黑棋获胜！");
                        break;
                    }
                    else{
                        p = false;//进入白棋下子
                    }
                } else {
                    System.out.println("无效棋！请重新下子！");
                }
            }
            else {
                System.out.println("请白子下子：");
                int y = sc.nextInt() - 1;
                int x = sc.nextInt() - 1;
                Boolean t = Demo7.check(x, y);
                if (t) {
                    qp[y][x] = white;
                    printQP();
                    //判断输赢
                    Boolean w=iswin(y, x, white);
                    if(w){
                        System.out.println("白棋获胜！");
                        break;
                    }
                    else{
                        p = true;//有效则进入下一轮
                    }
                }
                else {
                    System.out.println("无效棋！请重新下子！");
                }
            }
        }
    }

    //判断是否为无效子
    public static boolean check(int x, int y) {
        if (x < 0 || x > qp.length - 1 || y < 0 || y > qp.length - 1) {//判断是否超出边界
            return false;
        }
        if (!qp[y][x].equals(line)) {//判断位置是否下过棋子
            return false;
        }
        return true;
    }
    //判断输赢
    public static boolean iswin(int y, int x, String qz) {
        int spsum=1;//水平计数器
        for(int lx=x-1;lx>=0;lx--){//水平向左查找
            if(qp[y][lx].equals(qz)){
                spsum++;
            }else{
                break;
            }
            if(spsum>=5){
                return true;
            }
        }
        for(int rx=x+1;rx<qp.length-1;rx++){//水平向右查找
            if(qp[y][rx].equals(qz)){
                spsum++;
            }else{
                break;
            }
            if(spsum>=5){
                return true;
            }
        }
        int szsum=1;//竖直计数器
        for(int ny=y-1;ny>=0;ny--){//竖直向上查找
            if(qp[ny][x].equals(qz)){
                szsum++;
            }else{
                break;
            }
            if(szsum>=5){
                return true;
            }
        }
        for(int sy=y+1;sy<qp.length-1;sy++){//数值向下查找
            if(qp[sy][x].equals(qz)){
                szsum++;
            }else{
                break;
            }
            if(szsum>=5){
                return true;
            }
        }
        int lsum=1;//左对角计数器
        for(int lnx=x-1,lny=y-1;lnx>=0&&lny>=0;lnx--,lny--){//左斜向上查找
            if(qp[lny][lnx].equals(qz)){
                lsum++;
            }else{
                break;
            }
            if(lsum>=5){
                return true;
            }
        }
        for(int lsx=x+1,lsy=y+1;lsx<qp.length-1&&lsy<qp.length-1;lsx++,lsy++){//左斜向下查找
            if(qp[lsy][lsx].equals(qz)){
                lsum++;
            }else{
                break;
            }
            if(lsum>=5){
                return true;
            }
        }
        int rsum=1;//右对角计数器
        for(int rnx=x+1,rny=y-1;rnx<qp.length-1&&rny>=0;rnx++,rny--){//右斜向上查找
            if(qp[rny][rnx].equals(qz)){
                rsum++;
            }else{
                break;
            }
            if(rsum>=5){
                return true;
            }
        }
        for(int rsx=x-1,rsy=y+1;rsy<qp.length-1&&rsx>=0;rsy++,rsx--){//右斜向下查找
            if(qp[rsy][rsx].equals(qz)){
                rsum++;
            }else{
                break;
            }
            if(rsum>=5){
                return true;
            }
        }
        return false;
    }
}

结果展示

（1）打印棋盘，黑子先落子

（2）落子有效，白棋落子，进行循环

（3）判断出是无效子，重新落子

（4）判断输赢，结束对弈

高手敏smart_sheep

关注

3
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
用Java实现五子棋对弈

注：索引从0开始，故输入值均减一，在这里创建了check方法，来检查棋子是否有效，有效则返回true，替换上黑棋，打印棋盘，判断输赢，同样，创建iswin方法，未获胜，则令p=false，进入白棋落子,这里的y代表行数，x代表列数；每下一个棋子都要判断输赢，以当前下的棋子为中心，以水平为例，设定一个水平计数器，int spsum=1，先向左找，知道第0列，spsum>=5，如果不够，则继续向右找，直至
复制链接

扫一扫