Java作业-模拟扎金花

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量33 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LDK195403806/article/details/132915544
版权

要求
实现扑克牌的创建、洗牌、发牌、大小对比，输出赢家牌。

前提条件
首先需要创建三个集合，用于存储牌面值、牌号与比较规则，再创建一个类作为牌。

其次还需要了解到一个工具类，就是Collections类，该类的所有方法都是由 static 静态关键字修饰的，所以该类的所有方法都可直接使用 类名+. 的方式调用。
Collections类是针对集合的一个工具类，里面的所有方法就是针对集合来写的。

下面两个方法就是给类中给定的方法。

扑克牌的创建

使用一个静态代码块来构建牌，初始化牌盒、牌号与大小规则等。
静态代码块是一种特殊的语法结构，它允许你在类加载到JVM时执行某些操作。这种结构常用于一次性的设置或初始化静态变量。
静态代码块在类被加载时执行一次，并且只执行一次。

 // 准备牌
    static {
        map=new HashMap<>();
        pokerBox=new HashMap<>();
        listPoker=new ArrayList<>();
 
        // 将牌号存入map集合，用于比较时的牌大小对比
        map.put("2",2);
        map.put("3",3);
        map.put("4",4);
        map.put("5",5);
        map.put("6",6);
        map.put("7",7);
        map.put("8",8);
        map.put("9",9);
        map.put("10",10);
        map.put("J",11);
        map.put("Q",12);
        map.put("K",13);
        map.put("A",14);
 
        map.put("234",15);
        map.put("345",16);
        map.put("456",17);
        map.put("678",18);
        map.put("789",19);
        map.put("8910",20);
        map.put("910J",21);
        map.put("JQK",22);
        map.put("QKA",23);
 
        map.put("222",24);
        map.put("333",25);
        map.put("444",26);
        map.put("555",27);
        map.put("666",28);
        map.put("777",29);
        map.put("999",30);
        map.put("101010",31);
        map.put("JJJ",32);
        map.put("QQQ",33);
        map.put("KKK",34);
        map.put("AAA",35);
 
        // 235通吃(保留）
        map.put("235",999999999);
 
        // 花色
        String[] FlowerColor=new String[]{"♦","♣","♥","♠"};
        // 字母牌
        String[] letter=new String[]{"J","Q","K","A"};
 
        // 数字牌部分
        int keyIndex=0;
        for (int i = 2; i < 11; i++) {
            for (int j = 0; j < FlowerColor.length; j++) {
                listPoker.add(keyIndex);    // 存放序号
                pokerBox.put(keyIndex++,new 2poker(FlowerColor[j],i+"",FlowerColor[j]+i));  // 将序号与牌产生对应关系
            }
        }
 
        // 字母牌部分
        for (int i = 0; i < letter.length; i++) {
            for (int j = 0; j < FlowerColor.length; j++) {
                listPoker.add(keyIndex);
                // 将牌号与牌存入牌盒中
                pokerBox.put(keyIndex++,new poker(FlowerColor[j],letter[i],FlowerColor[j]+letter[i]));
            }
        }
    }

洗牌

由于牌号内的序号是与牌盒中的牌一一对应的，那么将存储牌号的list集合打乱就可以达到洗牌的效果。

// 洗牌
public void pokerShuffle(){
	// shuffle方法作用是将指定List集合使用默认随机源进行置换，也就是打乱List集合内元素的位置，当然该方法只对List集合有效。
  	Collections.shuffle(listPoker); // 打乱牌的序号
}

发牌

List集合与List集合之间是可以嵌套的，使用List<List>作为该方法的返回值，外层的List集合中代码每一个玩家，内层的List中代表玩家的扑克牌数。

public List<List<Integer>> dealCards(int playerNumber){
        // 对人数进行限制
        if((playerNumber*3) > pokerBox.size() || playerNumber <= 0){
            System.out.println("玩家超出限制，最多允许17位玩家、最少1一位玩家参加此游戏,请重新选择人数");
            return null;
        }
 
        // 玩家列表
        List<List<Integer>> playerList=new ArrayList<>();
        int k=3;    // 每位玩家牌的张数
 
        for (int i = 0,curIntdex=0; i < playerNumber; i++) {
            List<Integer> curPlayer=new ArrayList<>();
            // 每位玩家发三张牌
            for (int j = 0; j < k; j++) {
                curPlayer.add(listPoker.get(curIntdex++));
            }
            playerList.add(curPlayer); // 将当前玩家添加到玩家列表中
        }
 
        return playerList;
    }

看牌

// 看牌
    public void lookPoker(List<List<Integer>> list){
        // 所有玩家
        for(int i=0,end=list.size(); i<end; ++i){
            System.out.print("玩家"+(i+1)+"：");
            // 代表当前玩家
            List<Integer> curPople=list.get(i);
            // 玩家手中的牌
            for(int j=0,n=curPople.size(); j<n; ++j){
                // 从当前玩家curPople手中获取牌得序号，根据序号从牌盒PokerBox中取出牌来
                System.out.print(pokerBox.get(curPople.get(j)).value + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

内排序

对每个玩家的手牌内部进行排序。

// 玩家手牌进行排序
    public void playerPokerSort(List<List<Integer>> lists){
        // 最大手牌在第一位，第二次之....
        for (int i = 0; i < lists.size(); i++) {
            // 排序，逆序
            Collections.sort(lists.get(i),((o1, o2) -> (o2-o1)));
        }
    }

牌与牌之间的比较方法

返回值：

  • 大于0：玩家a的手牌 大于 玩家b的手牌
  • 小于0：玩家a的手牌 小于 玩家b的手牌
  • 等于0：玩家a的手牌 等于 玩家b的手牌 
    // 比较函数
    public int cmp(List<Integer> a,List<Integer> b){
        // O(a.size)
        StringBuilder sbA=new StringBuilder();
        StringBuilder sbB=new StringBuilder();
        // 逆序取
        for(int i=a.size()-1; i>=0; --i){
            sbA.append(pokerBox.get(a.get(i)).faceValue);
            sbB.append(pokerBox.get(b.get(i)).faceValue);
        }
		// 判断是否存在顺子牌等的情况
        Integer numA=map.get(sbA.toString());
        Integer numB=map.get(sbB.toString());
        if((numA != null && null == numB) || (null == numA && numB != null)){
            return (null == numA) ? -1 : 1;
        }else if(numA != null && numB != null){
            return numA-numB;
        }
 
        // O(a.size)
        for(int i=0,end=a.size(); i < end; ++i) {
            // 从两个玩家手中获取牌根号，获取到牌号后再从牌盒中取出牌面值来
            // 再从map中获取牌面值的大小，进行比较
            numA=map.get(pokerBox.get(a.get(i)).faceValue);
            numB=map.get(pokerBox.get(b.get(i)).faceValue);
			
            if (numA == numB) { continue; }
            if (numA > numB) { return 1; }
            else { return -1; }
        }
        // 相等的情况
        return 0;
    }

    找出牌最大的玩家

    // 输出最大玩家的手牌
public void printWinPlayer(List<List<Integer>> list){
    int maxIndex=0;
    List<Integer> maxPlayer=list.get(0);
 
    // 循环比较出最大玩家
    for(int i=1,end=list.size(); i<end; ++i){
        List<Integer> cur=list.get(i);
        // 根据比较方法来找出牌最大的玩家
        if(cmp(maxPlayer,cur) < 0){
            maxIndex=i;
            maxPlayer=cur;
        }
    }
 
    System.out.print("最大的手牌是玩家"+(maxIndex+1)+"：");
 
    List<Integer> ans=list.get(maxIndex);
    for(Integer i : ans){
        System.out.print(pokerBox.get(i).value + " ");
    }
    System.out.println();
}

    完整代码

    运行结果

  •  启动代码

    package newGame;
 
public class app {
    public static void main(String[] args) {
        new pokerGame();
    }
}

     游戏代码

    package newGame;
 
import java.util.*;
 
public class pokerGame {
 
    // 由于牌盒不需要排序，那么使用hashMap即可
    private static HashMap<Integer,poker> pokerBox; // 牌盒
     /*
     存储牌盒中的key键值，与牌盒中的牌一一对应，用于取出牌盒中的牌，对牌号的操作等同于对牌盒操作
     但是对Integer类型操作比对String类型操作更简单。
     同时牌号也能表示不同花色间的大小关系
     */
    private static List<Integer> listPoker; // 牌号
 
    private static HashMap<String,Integer> map; // 存储牌面值的大小规则
 
    // 准备牌
    static {
        map=new HashMap<>();
        pokerBox=new HashMap<>();
        listPoker=new ArrayList<>();
 
        // 将牌号存入map集合，用于比较时的牌大小对比
        map.put("2",2);
        map.put("3",3);
        map.put("4",4);
        map.put("5",5);
        map.put("6",6);
        map.put("7",7);
        map.put("8",8);
        map.put("9",9);
        map.put("10",10);
        map.put("J",11);
        map.put("Q",12);
        map.put("K",13);
        map.put("A",14);
 
        map.put("234",15);
        map.put("345",16);
        map.put("456",17);
        map.put("678",18);
        map.put("789",19);
        map.put("8910",20);
        map.put("910J",21);
        map.put("JQK",22);
        map.put("QKA",23);
 
        map.put("222",24);
        map.put("333",25);
        map.put("444",26);
        map.put("555",27);
        map.put("666",28);
        map.put("777",29);
        map.put("999",30);
        map.put("101010",31);
        map.put("JJJ",32);
        map.put("QQQ",33);
        map.put("KKK",34);
        map.put("AAA",35);
 
        // 最大值(保留）
        map.put("235",1000);
 
        // 花色
        String[] FlowerColor=new String[]{"♦","♣","♥","♠"};
        // 字母牌
        String[] letter=new String[]{"J","Q","K","A"};
 
        // 数字牌部分
        int keyIndex=0;
        for (int i = 2; i < 11; i++) {
            for (int j = 0; j < FlowerColor.length; j++) {
                listPoker.add(keyIndex);    // 存放序号
                pokerBox.put(keyIndex++,new poker(FlowerColor[j],i+"",FlowerColor[j]+i));  // 将序号与牌产生对应关系
            }
        }
 
        // 字母牌部分
        for (int i = 0; i < letter.length; i++) {
            for (int j = 0; j < FlowerColor.length; j++) {
                listPoker.add(keyIndex);
                pokerBox.put(keyIndex++,new poker(FlowerColor[j],letter[i],FlowerColor[j]+letter[i]));
            }
        }
    }
    // 洗牌
    public void pokerShuffle(){
        Collections.shuffle(listPoker); // 打乱牌的序号
    }
    // 发牌
    public List<List<Integer>> dealCards(int playerNumber){
        // 对人数进行限制
        if((playerNumber*3) > pokerBox.size() || playerNumber <= 0){
            System.out.println("玩家超出限制，最多允许17位玩家、最少1一位玩家参加此游戏,请重新选择人数");
            return null;
        }
 
        // 玩家列表
        List<List<Integer>> playerList=new ArrayList<>();
        int k=3;    // 每位玩家牌的张数
 
        for (int i = 0,curIntdex=0; i < playerNumber; i++) {
            List<Integer> curPlayer=new ArrayList<>();
            // 每位玩家发三张牌
            for (int j = 0; j < k; j++) {
                curPlayer.add(listPoker.get(curIntdex++));
            }
            playerList.add(curPlayer); // 将当前玩家添加到玩家列表中
        }
 
        return playerList;
    }
 
    // 看牌
    public void lookPoker(List<List<Integer>> list){
        // 所有玩家
        for(int i=0,end=list.size(); i<end; ++i){
            System.out.print("玩家"+(i+1)+"：");
            // 代表当前玩家
            List<Integer> curPople=list.get(i);
            // 玩家手中的牌
            for(int j=0,n=curPople.size(); j<n; ++j){
                // 从当前玩家curPople手中获取牌得序号，根据序号从牌盒PokerBox中取出牌来
                System.out.print(pokerBox.get(curPople.get(j)).value + " ");
            }
            System.out.println();
        }
        System.out.println();
    }
 
    // 玩家手牌进行排序
    public void playerPokerSort(List<List<Integer>> lists){
        // 最大手牌在第一位，第二次之....
        for (int i = 0; i < lists.size(); i++) {
            // 排序，逆序
            Collections.sort(lists.get(i),((o1, o2) -> (o2-o1)));
        }
    }
 
    // 比较函数
    public int cmp(List<Integer> a,List<Integer> b){
        // O(a.size)
        StringBuilder sbA=new StringBuilder();
        StringBuilder sbB=new StringBuilder();
 
        // 逆序取
        for(int i=a.size()-1; i>=0; --i){
            sbA.append(pokerBox.get(a.get(i)).faceValue);
            sbB.append(pokerBox.get(b.get(i)).faceValue);
        }
 
        Integer numA=map.get(sbA.toString());
        Integer numB=map.get(sbB.toString());
        if((numA != null && null == numB) || (null == numA && numB != null)){
            return (null == numA) ? -1 : 1;
        }else if(numA != null && numB != null){
            return numA-numB;
        }
 
        // O(a.size)
        for(int i=0,end=a.size(); i < end; ++i) {
            // 从两个玩家手中获取牌根号，获取到牌号后再从牌盒中取出牌面值来
            // 再从map中获取牌面值的大小，进行比较
            numA=map.get(pokerBox.get(a.get(i)).faceValue);
            numB=map.get(pokerBox.get(b.get(i)).faceValue);
 
            if (numA == numB) { continue; }
            // a玩家大于b玩家的情况
            if (numA > numB) { return 1; }
            // 小于的情况
            else { return -1; }
 
        }
        // 相等的情况
        return 0;
    }
 
    // 输出最大玩家的手牌
    public void printWinPlayer(List<List<Integer>> list){
        int maxIndex=0;
        List<Integer> maxPlayer=list.get(0);
 
        // 循环比较出最大玩家
        for(int i=1,end=list.size(); i<end; ++i){
            List<Integer> cur=list.get(i);
            if(cmp(maxPlayer,cur) < 0){
                maxIndex=i;
                maxPlayer=cur;
            }
        }
 
        System.out.print("最大的手牌是玩家"+(maxIndex+1)+"：");
 
        List<Integer> ans=list.get(maxIndex);
        for(Integer i : ans){
            System.out.print(pokerBox.get(i).value + " ");
        }
        System.out.println();
    }
 
    public pokerGame(){
 
        // 同花顺的逻辑没有编写
 
        pokerShuffle(); // 洗牌
        int playyern=3; // 玩家人数
        List<List<Integer>> lists = dealCards(playyern);   // 发牌
        if(null == lists){
            System.out.println("玩家数不规范，程序退出");
            System.exit(-1);
        }
 
        lookPoker(lists);   // 看牌
 
        playerPokerSort(lists); // 每个玩家的手牌内进行排序
 
//        lookPoker(lists);
 
        printWinPlayer(lists);  // 输出手牌值最大的玩家
 
    }
 
}
 
class poker{
    // 花色与牌面值分离了
    // 汇总就是总值
    String flowerColor; // 花色
    String faceValue;   // 牌面值
    String value;       // 总值
 
    public poker(){}
 
    // 有参构造
    public poker(String flowerColor, String faceValue,String value) {
        this.flowerColor = flowerColor;
        this.faceValue = faceValue;
        this.value=value;
    }
}

    End

    基本功能是实现了，如果有别的需求可自行魔改。如遇bug，请评论告知。

LDK195403806
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java扎金花程序java
05-02
javaSE写的一个扎金花作业。该程序实现了扎金花游戏的所有功能。适合新学java的学者学习下。当然由于个人单独写的，时间也比较紧所有可能存在些小问题或者哪里实现方式不好。还望读者能够批评指出。
java版金花3人游戏逻辑代码
11-22
三人一起玩的zha金花游戏，代码实现随机9张牌，每人三张牌，判断牌面大小
行业分类-设备装置-一种金花小檗提取物及其制备方法和用途.zip
09-04
标题中的“行业分类-设备装置-一种金花小檗提取物及其制备方法和用途”表明，这是一份关于制药或生物技术领域的技术文档，主要关注金花小檗这种植物的提取物，以及其提取过程、制备技术和可能的应用。金花小檗是一种...
基于JAVA语言开发的扎金花小游戏
06-18
JAVA语言开发的一个扎金花小游戏。仅供参考
抓金花游戏(java版）
10-05
【抓金花游戏（Java版）】是一款使用Java编程语言实现的桌面娱乐游戏，它基于中国流行的扑克牌玩法“三公”（也称“金花”）。在这个游戏中，玩家通过比较手中的三张牌来决定胜负，牌型的大小决定了游戏的结果。本...
redis+spring面试题
github_36510643的博客
07-21 151
redis+spring面试题
Java-Lambda
最新发布
lizhiwei21的博客
07-21 138
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 486
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1126
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1121
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 174
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1048
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 500
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 536
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 469
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 1022
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 228
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
python--实验14 并发编程（多线程）
wumingzei的博客
07-18 943
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
世纪金花：服务转型与零售生态标杆研究——万达百货深度合作解析
世纪金花服务转型项目是一个针对零售行业的前瞻性研究，以世纪金花作为案例，探讨如何通过以客户为中心的服务转型来构建零售业生态圈并实现业务拓展。该研究重点关注世纪金花在业务运营、客户服务和管理支撑三个关键...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值