Java -- 斗地主(后台版)

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量1.6k 收藏 31
点赞数 28
分类专栏： Java 文章标签： java windows 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74001893/article/details/140786872
版权

@[TOC](Java – 斗地主(后台版))

总纲

在这里插入图片描述

前期准备

  1. 创建程序启动入口App
public class App {
    public static void main(String[] args) {
        /*
            完成控制台的三步:
                准备牌
                发牌
                洗牌

            "♦", "♣", "♥", "♠"
            "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
         */
    }
}
  1. 创建PokerGame类
public class PokerGame {

}
  1. 在PokerGame类中添加空参构造器
public class PokerGame {

    public PokerGame() {
        // 准备牌
        // 洗牌
        // 发牌
        // 看牌
    }
}
  1. 创建App中引用(创建)PokerGame进入程序
// 进入程序
new PokerGame();

1.准备牌

在这里插入图片描述

1.1 准备牌思路

  1. 创建连个数组,分别存储花色和数字
  2. 创建一个集合,作为牌盒,后期会抽取为成员变量
  3. 遍历花色数组
  4. 遍历数字数组
  5. 将遍历获得的花色和数字拼接起来,添加到集合(牌盒)中
  6. 向牌盒中添加小王和大王

1.2 代码实现

  1. 准备一副牌,然后多次使用,此时可以用静态代码块进行编写.
    静态代码块的特点: 随着类的加载而加载,并且只执行一次
static {
        // 准备牌:
        // 1.创建数组存储花色   "♦", "♣", "♥", "♠"
        String[] color = {"♦", "♣", "♥", "♠"};
        // 2.创建数组存储数字   "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        // 3.创建一个集合作为牌盒
        ArrayList<String > list = new ArrayList<>();
        // 4.循环花色数组,获取每一种花色
        for (String c : color) {
            // 5.循环数字数组,获取每一个数字
            for (String n : number) {
                // 6.将遍历获得的 花色 和 数字 拼接起来,并添加到集合中
                list.add(c + n);
            }
        }
        // 7.添加大小王
        list.add("小王");
        list.add("大王");
    }
  1. 由于牌盒list需要在构造方法内使用,所以将list集合定义为成员变量
// 3.创建一个集合作为牌盒
// 添加static关键字,因为静态只能访问静态资源
static ArrayList<String > list = new ArrayList<>();

2.洗牌

在这里插入图片描述

2.1 思路

在构造方法中,直接使用Collections工具类的shuffle方法即可

// 洗牌
Collections.shuffle(list);
System.out.println(list);

3.发牌

在这里插入图片描述

3.1 发牌思路

  1. 创建四个集合,分别存储 底牌 玩家1,玩家2,玩家3 的牌
  2. 遍历集合
  3. 将获取的前三张牌作为底牌,存储 底牌(lord) 中
  4. 将剩下的牌轮流发给三位玩家

3.2 代码实现

// 1.创建四个结合分别存储 底牌 ,玩家1,玩家2,玩家3
        ArrayList<String> lord = new ArrayList<>();
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        // 2.遍历集合,获取每一张牌,将前三张作为底牌,后面的牌轮流发给三个玩家
        // 2.1 遍历集合
        for (int i = 0; i < list.size(); i++) {
            String poker = list.get(i);
            
            // 2.2 将前三张牌作为底牌存起来
            if (i <= 2){
                lord.add(poker);
                continue;
            }

            // 2.3 将后面的牌轮流发给三个玩家
            if (i % 3 == 0){ // 发给玩家1
                player1.add(poker);
            }else if (i % 3 == 1){ // 发给玩家2
                player2.add(poker);
            }else{ // 发给玩家3
                player3.add(poker);
            }
        }

4.看牌(可省略 – 只做验证使用)

4.1 思路

定义一个方法,实现看牌功能

  1. 打印玩家名字
  2. 遍历集合,获取每一张牌
  3. 将每一张牌进行打印
  4. 打印一个回车换行

4.2 代码实现

  1. 定义方法
/**
     * 看牌
     * @param name 每位玩家的名字
     * @param list 每一位玩家的牌
     */
    private void lookPoker(String name, ArrayList<String> list) {

        // 1.打印玩家名字
        System.out.print(name + ": ");
        // 2.遍历集合,拼接字符串
        for (String poker : list) {
            System.out.print(poker + " ");
        }
        System.out.println();
    }
  1. 调用方法
// 看牌
lookPoker("底牌",lord);
lookPoker("玩家1",player1);
lookPoker("玩家2",player2);
lookPoker("玩家3",player3);

5.排序(两种方式)

在这里插入图片描述

5.1 第一种方式(利用序号进行排序)

5.1.1 分析

在这里插入图片描述
在这里插入图片描述
先把牌进行手动排列,再让排列后的牌和1,2,3…进行对应,对应的数字越大,牌也就越大.
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5.1.2 思路

1.准备牌思路
  1. 创建Map集合,让序号和每一张牌产生联系
  2. 创建list集合,存储生成的序号
  3. 创建两个集合,分别存储 花色 和 数字
  4. 创建 初始序号
  5. 循环数字数组
  6. 循环花色数组
  7. 把获取到的 数字 和 花色 进行拼接,并添加到Map集合中
  8. 让序号自增
  9. 将序号添加到list集合中
  10. 添加小王,序号自增,再添加大王
2.洗牌思路
  1. 利用Collections工具类的shuffle方法进行洗牌
3.排序(发牌)思路
  1. 利用TreeSet集合进行优化,因为TreeSet集合会进行自动排序
  2. 创建四个TreeSet集合
  3. 遍历list序号集合
  4. 向四个集合中添加元素
4.看牌思路

定义方法,实现看牌功能
1.创建 StringJoiner对象,设置分隔符
2. 遍历list集合,通过键找值的方式,获取每一张牌的牌面
3. 将每一张面通过sj对象进行拼接
4. 将获得牌面进行拼接

5.1.3 代码实现

1.前期准备
  1. 创建程序的启动入口
  2. 创建程序类PokerGame
public class PokerGame {

    // 牌盒 Map
    static {
        // 1.创建数组存储花色   "♦", "♣", "♥", "♠"
        String[] color = {"♦", "♣", "♥", "♠"};
        // 2.创建数组存储数字   "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    }

    public PokerGame() {

    }
}
2.准备牌
// 牌盒 Map
    static HashMap<Integer, String> hm = new HashMap<>();
    // 序号
    static ArrayList<Integer> list = new ArrayList<>();

    static {
        // 1.创建数组存储花色   "♦", "♣", "♥", "♠"
        String[] color = {"♦", "♣", "♥", "♠"};
        // 2.创建数组存储数字   "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};

        // 3.定义一个变量,存储初始序号
        int serialNumber = 1;
        // 4.循环数字数组
        for (String n : number) {
            // 5.循环花色数组
            for (String c : color) {
                // 6.让序号和牌之间产生联系,并存入Map集合中
                hm.put(serialNumber, c + n);
                // 7.将序号存入list集合中,然后让序号自增
                list.add(serialNumber);
                serialNumber++;
            }
        }
        // 8.将小王存入Map集合,将小王的序号添加到list集合中,让序号自增
        hm.put(serialNumber,"小王");
        list.add(serialNumber);
        serialNumber++;
        // 9.将小王存入Map集合,将小王的序号添加到list集合中
        hm.put(serialNumber,"大王");
        list.add(serialNumber);
3.洗牌
// 洗牌
Collections.shuffle(list);
4.排序(发牌)
// 发牌
        // 1.创建四个TreeSet集合
        TreeSet<Integer> lord = new TreeSet<>();
        TreeSet<Integer> player1 = new TreeSet<>();
        TreeSet<Integer> player2 = new TreeSet<>();
        TreeSet<Integer> player3 = new TreeSet<>();
        // 2.遍历list序号集合
        for (int i = 0; i < list.size(); i++) {
            // i : 表示元素的索引
            // list.get(i) : 每一张牌的序号
            Integer serialNumber = list.get(i);
            // 3.向四个集合中添加元素
            if (i <= 2){ // 地主
                lord.add(serialNumber);
                continue;
            }

            if (i % 3 == 0){ // 玩家1
                player1.add(serialNumber);
            }else if (i % 3 == 1){ // 玩家2
                player2.add(serialNumber);
            }else { // 玩家3
                player3.add(serialNumber);
            }
        }
5.看牌
/**
     * 看牌功能
     *
     * @param name 玩家的名字
     * @param list 发到的牌
     */
    private void lookCards(String name, TreeSet<Integer> list) {

        // 1.遍历集合,获取每一张的序号,通过键找值的方式获取对应的牌面
        StringJoiner sj = new StringJoiner(", ", "", "");
        // 1.1 遍历集合,获取每一张的序号
        for (Integer number : list) {
            // 1.2 通过键找值的方式获取对应的牌面,并进行拼接
            String poker = hm.get(number);
            sj.add(poker);
        }
        // 2.拼接成字符串进行打印
        System.out.println(name + " : " + sj);
    }
  1. 调用看牌功能
// 看牌
lookCards("地主", lord);
lookCards("玩家1", player1);
lookCards("玩家2", player2);
lookCards("玩家3", player3);

5.2 第二种方式(给每张牌计算价值)

5.2.1 分析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5.2.2 思路

1.排序思路
  1. 在成员位置创建一个HashMap集合,作为牌的价值容器
  2. 在静态代码块中为每张牌添加对应的价值
  3. 定义一个方法,对发牌进行排序
  • 使用list集合调用sort方法进行排序
  • 使用的是添加排序器(Comparator)的方式
  • 在排序器中指定比较规则
  • 先取出两张牌的花色
  • 再定义一个方法去获取每张牌的价值
  • 比较规则为: 如果价值相同,就去比较花色的值
  1. 在定义的getValue方法中,对传递过来的poker进行截取
  • 截取方式为: 从索引为1的字符开始截取,直到末尾
  • 对截取的数字进行判断,判断其是否存在于hm集合中
  • 如果存在,则从集合中取出价值进行返回
  • 如果不存在,则将其本身作为价值进行返回
  1. 注意: 由于是从索引1开始截取,而牌盒中有两张特殊的牌,大王和小王,如果按照原来添加的字符串进行截取,则会截取到字符 “王”.而我们在存储每张牌的价值的时候,并没有存储字符"王",我们存储的是"大王"和"小王".此时,我们采取的解决方案是:**在添加价值的时候,在字符串"大王"和"小王"的时候,在两个字符串前面添加一个空格,添加完成后的字符串为 " 小王" 和 " 大王".**到此,此问题得以解决.

5.2.3 代码实现

1.前期准备
  1. 程序入口APP
  2. 准备牌,洗牌,发牌
public class PokerGame {

    // 3.创建一个集合作为牌盒
    // 添加static关键字,因为静态只能访问静态资源
    static ArrayList<String > list = new ArrayList<>();

    // 准备牌
    // 静态代码块:
    //  特点: 随着类的加载而加载,并且只执行一次
    static {
        // 准备牌:
        // 1.创建数组存储花色   "♦", "♣", "♥", "♠"
        String[] color = {"♦", "♣", "♥", "♠"};
        // 2.创建数组存储数字   "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};

        // 4.循环花色数组,获取每一种花色
        for (String c : color) {
            // 5.循环数字数组,获取每一个数字
            for (String n : number) {
                // 6.将遍历获得的 花色 和 数字 拼接起来,并添加到集合中
                list.add(c + n);
            }
        }
        // 7.添加大小王
        list.add("小王");
        list.add("大王");
    }

    public PokerGame() {

        // 洗牌
        Collections.shuffle(list);
        System.out.println(list);
        // 发牌
        // 1.创建四个结合分别存储 底牌 ,玩家1,玩家2,玩家3
        ArrayList<String> lord = new ArrayList<>();
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        // 2.遍历集合,获取每一张牌,将前三张作为底牌,后面的牌轮流发给三个玩家
        // 2.1 遍历集合
        for (int i = 0; i < list.size(); i++) {
            String poker = list.get(i);

            // 2.2 将前三张牌作为底牌存起来
            if (i <= 2){
                lord.add(poker);
                continue;
            }

            // 2.3 将后面的牌轮流发给三个玩家
            if (i % 3 == 0){ // 发给玩家1
                player1.add(poker);
            }else if (i % 3 == 1){ // 发给玩家2
                player2.add(poker);
            }else{ // 发给玩家3
                player3.add(poker);
            }
        }
    }
}
2.指定牌的价值
  1. 在PokerGame中添加成员变量hm,用于添加牌的价值
//创建一个集合，用来添加牌的价值
static HashMap<String, Integer> hm = new HashMap<>();
  1. 在静态代码块中添加牌的价值
//指定牌的价值
//牌上的数字到Map集合中判断是否存在
//存在，获取价值
//不存在，本身的数字就是价值
hm.put("J", 11);
hm.put("Q", 12);
hm.put("K", 13);
hm.put("A", 14);
hm.put("2", 15);
hm.put("小王", 50);
hm.put("大王", 100);
3.排序(Order)
/**
     * 定义方法,完成排序功能
     *
     * @param list 发给玩家的牌的集合
     */
    private void order(ArrayList<String> list) {

        // 1.使用Collections工具类调用sort方法,并指定排序规则
        // 1.1 调用sort方法
        // sort 的底层采用的是 二分查找 和 插入排序 的方式进行排序的
        Collections.sort(list, new Comparator<String>() {
            @Override
            // o1 : 表示要插入到前面有序序列里面的牌
            // o2 : 已存在的有序序列中的牌

            // 正数 : o1大  插入到后面
            // 负数 : o1小  插入到前面
            // 0 : o1跟o2的价值是一样的,需要再根据花色进行排序

            public int compare(String o1, String o2) {
                // 1.2 指定排序规则
                // 1.2.1 获取花色
                String color1 = o1.substring(0, 1);
                String color2 = o2.substring(0, 1);
                // 1.2.2 获取价值,定义方法
                int value1 = getValue(o1);
                int value2 = getValue(o2);
                // 指定排序规则
                int i = value1 - value2;
                return i == 0 ? color1.compareTo(color2) : i;
            }
        });
    }
4.获取价值方法(getValue)
/**
     * 获取每张牌的价值
     *
     * @param poker 牌
     * @return 价值
     */
    public int getValue(String poker) {

        // 1.从索引1开始截取字符串
        String number = poker.substring(1);
        // 2.通过截取的字符串进行判断,判断截取的字符串是否存在于hm集合中
        if (hm.containsKey(number)) {
            // 2.1 如果存在,则需要从集合中取出对应的价值,进行返回
            return hm.get(number);
        } else {
            // 2.2 如果不存在,则直接把截取的字符串本身作为价值进行返回,但需要进行强制转换
            return Integer.parseInt(number);
        }
    }

6.面向对象的设计

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

帝修罗
关注
专栏目录
java课程设计斗地主_Java课程设计---web版斗地主
weixin_34024555的博客
02-19 364
一.团队课程设计博客链接https://www.cnblogs.com/lanxiang/p/10293812.html二.个人负责模块和任务说明负责前后端数据传输JSP界面的设计根据后台传来的数据进行页面动态更新负责Servlet设计三.自己的代码提交记录截图 四.自己负责模块或任务详细说明登入页面设计和后台的数据交互： 获取数据库信息，将信息显示在排行榜上 通过后台传来的数据，动态更新界面，...
斗地主Java课程设计_Java课程设计---web版斗地主
weixin_36160969的博客
02-13 382
一.团队课程设计博客链接https://www.cnblogs.com/lanxiang/p/10293812.html二.个人负责模块和任务说明负责前后端数据传输JSP界面的设计根据后台传来的数据进行页面动态更新负责Servlet设计三.自己的代码提交记录截图四.自己负责模块或任务详细说明登入页面设计和后台的数据交互：获取数据库信息，将信息显示在排行榜上通过后台传来的数据，动态更新界面，完成斗...
Java斗地主小案例（后台版）
weixin_43350001的博客
02-05 358
import java.util.ArrayList; import java.util.Collections; /** * @Author HM.ming * @Date 2022/1/2 11:16 * @Version 1.0 * * 斗地主小案例：实现洗牌，发牌，看牌 */ public class Demo01 { public static void main(String[] args) { // 1.创建牌 String[] color
Java课程设计---web版斗地主
weixin_30407613的博客
01-19 1291
一.团队课程设计博客链接 　　二.个人负责模块和任务说明 负责前后端数据传输 JSP界面的设计 根据后台传来的数据进行页面动态更新 负责Servlet设计 　三.自己的代码提交记录截图 　　 　四.自己负责模块或任务详细说明 登入页面设计和后台的数据交互： 获取数据库信息，将信息显示在排行榜上 通过后台传来的数据，动态更新...
JAVA简单游戏项目--斗地主游戏及登录注册界面 源码经过换皮优化 文章附源码直接拿
alex88ander的博客
12-29 954
于是导入javazoom下的Player类，构造方法抛出异常与文件无法找到的错误，为使音乐在不同路径下都能播放，采取项目路径与相对路径拼接为字符串，再将字符串传入文件输入流，并预先用缓冲流加载，while(true)死循环使音频不断播放。通过以上介绍，详细阐述了斗地主游戏代码的设计要求、数据模型、简单测试、视图设计、GUI程序、程序发布等方面的内容。本文档介绍斗地主游戏的设计要求、数据模型、简单测试、视图设计、GUI程序、程序发布等方面的内容，以提供一个全面而清晰的说明。空水杯交换 空水杯 = 数字字符；
20天学会Java-基础阶段笔记
Even的博客
01-14 1357
黑马程序的基础阶段笔记
斗地主Java课程设计_JAVA面向对象编程课程设计——web版斗地主
weixin_39630880的博客
02-13 1077
一、团队课程设计博客链接二、个人负责模块或任务说明实体类的设计斗地主规则的实现人机自动出牌的算法实现数据库的DAO模式三、自己的代码提交记录注：这里只有部分提交记录，详细的提交记录在团队课程设计博客里有四、自己负责模块或任务详细说明1、实体类的设计的代码分析游戏设计需要用到卡片类(Card)正反面，还有牌型(CardType)的设计，以及各种牌的组合，还要设计在游戏中的抢地主、出牌倒计时、出牌和不...
通过java控制台实现简单的斗地主系统
qq_60614034的博客
10-31 566
本文适合聪明的java初学者才可以看得懂！但是其中的出牌逻辑判断没有写，因为工作量太大了。怎么打牌就全靠大家自觉了，要是345678没有7我也没办法。。直接放代码。
Java学习-集合
weixin_46051964的博客
07-20 1112
集合是Java中存储对象数据的一种容器。注意集合中只能存储引用类型数据，如果要存储基本类型数据可以选用包装类。注意前期先掌握Collection集合体系的使用。
java版斗地主源码-DoraCMS-master:DoraCMS-master
06-04
java版斗地主源码 ##问题： 1、redis connection to 127.0.0.1:6379 failed 这个是redis连接不上的问题，请看这篇文章 2、failed to load c++ bson extension 这个问题不用管,node自己的问题,不影响程序运行 3、今天...
java版斗地主源码-C:C
06-04
java版斗地主源码 chessAndCard-2dx 收集 cocos2d-x 的棋牌项目 这里会导致卡顿, 1 改为 0 吧。 包含了客户端和服务器。 Creator 的牛牛  cocos creator 客户端，贝密游戏是一系列棋牌游戏的名称，其中包含麻将、...
java版斗地主源码-DoraCMS:内容管理系统
06-04
java版斗地主源码 ##问题： 1、redis connection to 127.0.0.1:6379 failed 这个是redis连接不上的问题，请看这篇文章 2、failed to load c++ bson extension 这个问题不用管,node自己的问题,不影响程序运行 3、今天...
java版斗地主源码-doracms:个人版
06-04
java版斗地主源码 ##问题： 1、redis connection to 127.0.0.1:6379 failed 这个是redis连接不上的问题，请看这篇文章 2、failed to load c++ bson extension 这个问题不用管,node自己的问题,不影响程序运行 3、今天...
java版斗地主源码-sodagames:苏打水游戏
06-04
java版斗地主源码 ##问题： 1、redis connection to 127.0.0.1:6379 failed 这个是redis连接不上的问题，请看这篇文章 2、failed to load c++ bson extension 这个问题不用管,node自己的问题,不影响程序运行 3、今天...
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 846
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 434
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 535
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 795
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Android --- 斗地主 [牌桌实现源码]
05-31
在具体实现时，可以利用Android提供的UI控件来进行界面设计，并利用Java的面向对象特性来实现各个类之间的交互。同时，需要注意代码的可读性、可维护性和扩展性，保证代码的质量。 另外，为了更好地理解斗地主游戏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值