基于Java的斗地主游戏案例开发（做牌、洗牌、发牌、看牌

于 2024-07-15 22:35:58 发布
阅读量293 收藏
点赞数 2
文章标签： java 游戏 windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65752158/article/details/140422669
版权 

package Game;

import java.util.ArrayList;
import java.util.Collections;

public class PokerGame01 {
    //牌盒
    //♥3 ♣3
    static ArrayList<String> list = new ArrayList<>();

    //静态代码块
    //特点：随着类的加载而在加载的，而且只执行一次。
    static {
        //准备牌
        // "♦", "♣", "♥", "♠"
        // "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
        String[] color = {"♦", "♣", "♥", "♠"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        for (String c : color) {
            //c表示每一个牌的花色
            for (String n : number) {
                //n表示每一种牌号
                list.add(c + n);
            }
        }
        list.add("大王");
        list.add("小王");

    }

    public PokerGame01() {
        // 洗牌
        Collections.shuffle(list);
        // 发牌
        //定义4个集合，其中3个选手的牌,还要一个是用来存储地主多出来的3张牌
        ArrayList<String> dizhu = new ArrayList<>();
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            //根据索引找到牌号，本质是要把前三张牌给地主
            String poke = list.get(i);//得到了第i张牌
            if (i <= 2) {
                dizhu.add(poke);//前三张给地主
                //依次轮流给3个选手发牌
            } else if (i % 3 == 0) {
                player1.add(poke);
            } else if (i % 3 == 1) {
                player2.add(poke);
            } else {
                player3.add(poke);
            }

        }
        //看牌
        lookpoke("张三",player1);
        lookpoke("李四",player2);
        lookpoke("王五",player3);

    }

    public void lookpoke(String name, ArrayList<String> list) {
        System.out.print(name + ": ");
        for (String poke : list) {
            //循环遍历得到每一张牌
            System.out.print(poke + " ");

        }
        System.out.println();
    }
}

排序的

package Game;

import java.util.*;

public class PokerGame02 {
    //牌盒
    //♥3 ♣3
    //键是序号，牌是值
    //此时只要把牌跟序号产生对应关系即可，不需要按照序号进行排序，所以只需HashMap即可
    static HashMap<Integer, String> hm = new HashMap<>();

    //用来存储序号的单列集合
    static ArrayList<Integer> list = new ArrayList<>();

    //静态代码块
    //特点：随着类的加载而在加载的，而且只执行一次。
    static {
        //准备牌
        // "♦", "♣", "♥", "♠"
        // "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
        String[] color = {"♦", "♣", "♥", "♠"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
/*
        {1=♦3, 2=♦4, 3=♦5, 4=♦6, 5=♦7, 6=♦8, 7=♦9, 8=♦10, 9=♦J, 10=♦Q, 11=♦K, 12=♦A, 13=♦2, 14=♣3,
        15=♣4, 16=♣5, 17=♣6, 18=♣7, 19=♣8, 20=♣9, 21=♣10, 22=♣J, 23=♣Q, 24=♣K, 25=♣A, 26=♣2, 27=♥3,
         28=♥4, 29=♥5, 30=♥6, 31=♥7, 32=♥8, 33=♥9, 34=♥10, 35=♥J, 36=♥Q, 37=♥K, 38=♥A, 39=♥2, 40=♠3,
         41=♠4, 42=♠5, 43=♠6, 44=♠7, 45=♠8, 46=♠9, 47=♠10, 48=♠J, 49=♠Q, 50=♠K, 51=♠A, 52=♠2}
         很明显可以看出没有按照顺序起好牌 应该先把数字一样的放在一起，而不是把花色一样的放在一起
         解决： 交换color和number即可
*/
        //定义一个序号
        int num = 1;

        for (String n : number) {
            //n表示每一种牌号
            for (String c : color) {
                //c表示每一个牌的花色
                hm.put(num, c + n);
                list.add(num);
                num++;
            }
        }
        hm.put(num, "小王");
        list.add(num);
        num++;
        hm.put(num, "大王");
        list.add(num);
    }

    public PokerGame02() {
        // 洗牌
        Collections.shuffle(list);
        // 发牌
        /*
[39, 35, 7]
[28, 31, 15, 54, 14, 24, 3, 46, 43, 22, 37, 41, 29, 45, 16, 30, 48]
[33, 49, 11, 13, 38, 27, 25, 50, 20, 9, 1, 32, 19, 10, 44, 21, 40]
[53, 8, 34, 36, 17, 42, 5, 18, 2, 23, 12, 26, 4, 47, 6, 51, 52]
用ArrayList集合存储的索引是乱序的，我们本质是要根据序号也就是索引去到map集合里面找到牌，所以序号要有序
 */
        /*
        [5, 10, 34]
        [2, 4, 7, 8, 13, 17, 18, 19, 20, 22, 27, 35, 37, 38, 39, 40, 42]
        [1, 9, 14, 16, 23, 24, 28, 29, 30, 31, 32, 36, 41, 43, 46, 51, 52]
        [3, 6, 11, 12, 15, 21, 25, 26, 33, 44, 45, 47, 48, 49, 50, 53, 54]
         */
        //定义4个集合，其中3个选手的牌,还要一个是用来存储地主多出来的3张牌
        TreeSet<Integer> dizhu = new TreeSet<>();
        TreeSet<Integer> player1 = new TreeSet<>();
        TreeSet<Integer> player2 = new TreeSet<>();
        TreeSet<Integer> player3 = new TreeSet<>();


        //获取所有的键，把这些键放入单列集合当中
        // Set<Integer> integers1 = hm.keySet();

        for (int i = 0; i < list.size(); i++) {
            //根据索引找到牌的序号，本质是要把前三张牌的序号给地主
            int number = list.get(i);  //得到了第i张牌的序号
            if (i <= 2) {
                dizhu.add(number); //前三张牌的序号给地主
                // integers1.add(poke);
                //依次轮流给3个选手发牌
            } else if (i % 3 == 0) {
                player1.add(number);
            } else if (i % 3 == 1) {
                player2.add(number);
            } else {
                player3.add(number);
            }

        }


        //看牌
        lookpoke("底牌",dizhu);
        lookpoke("张三",player1);
        lookpoke("李四",player2);
        lookpoke("王五",player3);


        // look("赵六",integers1);
    }


    /*
     * 参数一：玩家的名字
     * 参数二：牌的序号
     * */
    public void lookpoke(String name, TreeSet<Integer> ts) {
        System.out.print(name + ": ");
        for (int num : ts) {
            //num就是代表的是序号，遍历方法1 通过键找值的方式遍历map集合

            //遍历TreeSet集合得到每一个序号，再拿着序号到Map集合中去找真正的牌
            String poke = hm.get(num);//通过键（序号）拿到了每一张牌（值）
            System.out.print(poke + " ");
        }
        System.out.println();

    }

    //遍历单列集合，得到每一个键;
   /* public void look(String name, Set<Integer> key) {
        System.out.print(name+": ");
        //遍历单列集合，得到每一个键
        for (int num : key) {
            //num代表就是序号
            //通过序号（键）去找到map集合里面的值
            String value = hm.get(num);
            System.out.print(value+" ");

        }
        System.out.println();

    }*/
}


package Game;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;

public class PokerGame03 {
    //牌盒
    //♥3 ♣3
    static ArrayList<String> list = new ArrayList<>();
    //创建一个集合，用来添加牌的价值,牌号是键,价值是值
    static HashMap<String, Integer> hm = new HashMap<>();

    //静态代码块
    //特点：随着类的加载而在加载的，而且只执行一次。
    static {
        //准备牌
        // "♦", "♣", "♥", "♠"
        // "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
        String[] color = {"♦", "♣", "♥", "♠"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        for (String c : color) {
            //c表示每一个牌的花色
            for (String n : number) {
                //n表示每一种牌号
                list.add(c + n);
            }
        }
        list.add(" 大王");
        list.add(" 小王");
        //指定牌的价值
        //牌上的数字到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);
    }

    public PokerGame03() {
        // 洗牌
        Collections.shuffle(list);
        // 发牌
        //定义4个集合，其中3个选手的牌,还要一个是用来存储地主多出来的3张牌
        ArrayList<String> dizhu = new ArrayList<>();
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            //根据索引找到牌号，本质是要把前三张牌给地主
            String poke = list.get(i);//得到了第i张牌
            if (i <= 2) {
                dizhu.add(poke);//前三张给地主
                //依次轮流给3个选手发牌
            } else if (i % 3 == 0) {
                player1.add(poke);
            } else if (i % 3 == 1) {
                player2.add(poke);
            } else {
                player3.add(poke);
            }

        }
        //排序
        order(dizhu);
        order(player1);
        order(player2);
        order(player3);
        //看牌
        lookpoke("张三",player1);
        lookpoke("李四",player2);
        lookpoke("王五",player3);
        lookpoke("底牌",dizhu);

    }

    //利用牌的价值进行排序
    //参数：集合
    //♥5 ♥3 ♥6 ♥7 ♥9
    private void order(ArrayList<String> list) {
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //o1：表示当前要插入到有序序列中的牌
                //o2：表示已经在有序序列中存在的牌

                //负数：o1小 插入到前面
                //正数：o1大 插入到后面
                //0：o1的数字跟o2的数字是一样的，需要按照花色再次排序

                //1.计算o1的花色和价值  
                String color1 = o1.substring(0, 1);;//♥3中的♥
                //价值
                int value1 = getValue(o1);
                //2.计算o2的花色和价值
                String color2= o1.substring(0, 1);//♥3中的♥
                //价值
                int value2 = getValue(o2);
                //3.比较o1和o2的价值    ♥3  ♠3
                int i = value1 - value2;
                return i == 0 ? color1.compareTo(color2) : i;
            }
        });
    }

    //计算牌的价值
    //参数：牌
    //返回值：价值
    public int getValue(String poker) {  //♥3
        //获取牌上的数字
        String number = poker.substring(1);//比如♥3中的3
        //把这里截取出来的结果，让这个结果再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"的价值就值3
        //如果存在在map集合里面拿出对应的价值即可

        //拿着数字到map集合中判断是否存在
        if (hm.containsKey(number)) {
            //存在，获取价值
            return hm.get(number);
        } else {
            //不存在，类型转换
            return Integer.parseInt(number);
        }
    }
    public void lookpoke(String name, ArrayList<String> list) {
        System.out.print(name + ": ");
        for (String poke : list) {
            //循环遍历得到每一张牌
            System.out.print(poke + " ");

        }
        System.out.println();
    }
}

林的快手
关注
跳一跳j算法ava代码_麻将游戏算法深入解析及实现代码
weixin_34409903的博客
12-23 377
麻将游戏算法深入解析及实现代码这两天为了工具箱的完善，整理了这些年引擎开发的一些资料，无意中发现06年写的一个麻将算法，编译运行了一下，还是有点意思的，拿出来整理一下分享给大家。麻将是一种大家最喜爱的娱乐活动之一，相信所有人都有接触过。我写的这版算法，是可以吃，碰，杠，还有把牌摸完没有人胡时的皇庄和包听。是用控制台方式来表现的，什么？控制台？对，因为是算法的设计，所以用控制台来表现当然最简单了。当...
Java实现的麻将编程
01-16
使用Java写的麻将小程序。只支持单机，电脑玩家水平还可以。
麻将游戏Java源码
03-04
麻将游戏Java源码，含麻将，麻将学院，麻将中国龙三个游戏源码
java写的麻将小游戏
热门推荐
天地炫舞的博客
02-23 2万+
过年回家在家打麻将，觉得蛮有趣的，就用java写了一个麻将小游戏（没有界面，只能在控制台玩）。 说明： 使用语言：java（jdk1.7） 开发工具：eclipse 项目集成：maven 1 麻将说明 1.1 方位说明（请注意“人”这个玩家的位置） 1.2 规则说明 可以碰牌、杠牌 不能吃牌 有东西南北中发白 有癞子 可以自摸，可以放炮 其余的麻将知识请自行百度 ...
java 麻将小游戏
02-15
java 麻将小游戏 136张牌
基于Java的斗地主游戏案例开发（做牌、洗牌、发牌、看牌）
最新发布
m0_60961113的博客
04-04 370
斗地主游戏：发出51张牌，剩下3张作为底牌。点数："3","4","5","6","7","8","9","10","J","Q","K","A","2" 花色："♠","♥","♣","♦" 大小王："♚"大,"🤡"小。
随机发牌_Java项目实战：斗地主洗牌发牌小游戏
qq_25026797的博客
08-22 293
斗地主是全国范围内的一种桌面游戏，尽管全国各种类型，但大同小异。本节我们先来实现一下斗地主中的简单洗牌、发牌和看牌功能。按照斗地主的规则，完成洗牌发牌的动作。具体规则为使用 54 张牌打乱顺序，3 个玩家参与游戏，3 人交替摸牌，每人 17 张牌，后 3 张留作底牌。 实现思路步骤如下： 准备牌：Arrylist 集合储存，for 循环遍历实现 洗牌：使用 Collections 的shuffle(arryBox);方法刷新集合中的顺序 发牌：使用 for 循环遍历 Arryl
Java—斗地主的洗牌发牌系统（积小流成江海）
weixin_54620350的博客
03-27 6923
扑克牌经典游戏“斗地主”相信很多人都会玩，这次就用Java语言来编写一个斗地主的洗牌发牌程序，要求按照斗地主的规则完成洗牌发牌的过程。
【案例 6-4】斗地主洗牌发牌
菜鸟一枚。
11-18 2252
1.任务描述斗地主的扑克牌游戏，相信许多人都会玩，本例要求编写一个斗地主的洗牌发牌程序，要求按照斗地主的规则完成洗牌发牌的过程。一副扑克总共有 54 张牌，牌面由花色和数字组成（包括 J、Q、K、A 字母）组成，花色有♠、♥、♦、♣ 四种，分别表示黑桃、红桃、方块、梅花，小☺、大☻分别表示小王和大王。斗地主游戏共有三位玩家参与，首先将这 54张牌的顺序打乱每人轮流摸一次牌，剩余 3 张留作底牌，然后在控制台打印三位玩家的牌和三张底牌。2.运行结果略学会分析“斗地主之洗牌发牌”任务的实现思路。
JAVA麻将源代码
04-22
java游戏代码 很值得收藏
java斗地主发牌程序
05-29
【Java斗地主发牌程序】是一个典型的基于Java编程语言实现的桌面游戏应用，它主要用于模拟斗地主游戏中的发牌过程。在这个程序中，我们可以深入学习到Java的基础语法、面向对象编程思想以及随机数生成等核心概念。...
详解java_ 集合综合案例：斗地主
08-26
具体来说，文中将详细阐释如何通过Java的集合类创建一副扑克牌，如何实现洗牌和发牌的过程，并最终展示如何将牌分发给三位玩家和底牌。接下来将具体解析本案例中的知识点。 ### 1. 斗地主游戏规则简介 斗地主是一种...
斗地主 游戏UML图及java代码
12-27
总结，斗地主游戏的UML图和Java代码为我们提供了一个从设计到实现的完整案例，涵盖了软件开发的多个重要环节。无论是对于初学者还是经验丰富的开发者，都是一份宝贵的学习资源。通过深入研究，我们可以更好地掌握...
Java实现斗地主发牌
weixin_44296403的博客
09-09 1131
Java实现斗地主发牌，并自定义比较器，使用stream流的sorted方法进行排序
Java实现简单的斗地主案例（超详细代码）
weixin_46049908的博客
07-11 3585
案例说明：使用Java实现简单的斗地主洗牌发牌的操作 具体规则： 共有54张牌，顺序打乱； 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后留三张为底牌（地主牌）。 源码实现： /* * 集合题目： * 斗地主案例： * 1.准备牌（定义牌的花色和序号） * 2.洗牌（打乱顺序） * 3.发牌（玩家获取牌、底牌） * 4.看牌 * */ public static void main(String[] args) {
黑马JAVA P136 斗地主游戏
weixin_51015079的博客
01-16 3181
package com.itheima.d4_collection_test; import java.util.*; /** * 目标：斗地主游戏的案例开发。 * * 业务需求分析： * 斗地主的做牌，洗牌，发牌，排序（拓展知识）,看牌 * 业务：总共有54张牌。 * 点数："3","4","5","6","7","8","9","10","J","Q","K","A","2", * 花色："♠","♥","♣"，"♦" * 大小王：“大王”，“小王” * 点数分别...
请使用java编写自定义麻将游戏
weixin_42587866的博客
02-09 529
Java 是一种通用编程语言，可以用来编写自定义麻将游戏。 首先，你需要了解麻将游戏的基本规则和流程。然后，你可以使用 Java 的图形用户界面(GUI)库(如 Swing 或 JavaFX)来创建游戏界面。对于游戏的核心逻辑，你可以使用 Java 的类和方法来实现。 例如，你可以创建一个麻将牌的类，其中包含牌的花色、数字等属性。还可以创建一个玩家类，其中包含玩家的名字、手牌、积分等信息。 游戏的...
Java实现斗地主发牌系统详解
"Java 实现斗地主发牌系统是一个基于 Java 编程语言的程序设计，用于模拟斗地主游戏中的发牌过程。本文档将深入探讨如何使用 Java 设计一个基本的斗地主发牌系统，包括玩家类（Player）和牌类（Card）的设计，以及发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值