• 斗地主案例及一些实现规则

    4. 斗地主发牌

    4.1 案例介绍

    按照斗地主的规则，完成洗牌发牌的动作。 具体规则：

    使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。

    4.2 案例分析

    • 准备牌：

      牌可以设计为一个ArrayList,每个字符串为一张牌。 每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。 牌由Collections类的shuffle方法进行随机排序。

    • 发牌

      将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

    • 看牌

      直接打印每个集合。

    4.3 代码实现

    1. public class App {
    2.     public static void main(String[] args) {
    3.       /*
    4.         完成控制台版的三步：
    5.           准备牌
    6.           洗牌
    7.           发牌
    8.        */
    9.         //从程序的主入口开启斗地主游戏
    10.         new PokerGame();
    11.     }
    12. }
    13. ​
    14. public class PokerGame {
    15.     //牌盒
    16.     //♥3 ♣3
    17.     static ArrayList list = new ArrayList<>();
    18. ​
    19.     //静态代码块
    20.     //特点：随着类的加载而在加载的，而且只执行一次。
    21.     static {
    22.         //准备牌
    23.         // "♦", "♣", "♥", "♠"
    24.         // "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
    25.         String[] color = {"♦", "♣", "♥", "♠" };
    26.         String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    27. ​
    28.         for (String c : color) {
    29.             //c依次表示每一种花色
    30.             for (String n : number) {
    31.                 //n 依次表示每一个数字
    32.                 list.add(c + n);
    33.             }
    34.         }
    35.         list.add("小王");
    36.         list.add("大王");
    37.     }
    38. ​
    39.     public PokerGame(){
    40.         //洗牌
    41.         Collections.shuffle(list);
    42. ​
    43.         //发牌
    44.         ArrayList lord = new ArrayList<>();
    45.         ArrayList player1 = new ArrayList<>();
    46.         ArrayList player2 = new ArrayList<>();
    47.         ArrayList player3 = new ArrayList<>();
    48. ​
    49.         //遍历牌盒得到每一张牌
    50.         for (int i = 0; i < list.size(); i++) {
    51.             //i：索引
    52.             String poker = list.get(i);
    53.             if(i <= 2){
    54.                 lord.add(poker);
    55.                 continue;
    56.             }
    57. ​
    58.             //给三个玩家轮流发牌
    59.             if(i % 3 == 0){
    60.                 player1.add(poker);
    61.             }else if(i % 3 == 1){
    62.                 player2.add(poker);
    63.             }else{
    64.                 player3.add(poker);
    65.             }
    66.         }
    67.         //看牌
    68.         lookPoker("底牌",lord);
    69.         lookPoker("钢脑壳",player1);
    70.         lookPoker("大帅比",player2);
    71.         lookPoker("蛋筒",player3);
    72. ​
    73.     }
    74. ​
    75.     /*
    76.     * 参数一：玩家的名字
    77.     * 参数二：每位玩家的牌
    78.     * */
    79.     public void lookPoker(String name, ArrayList list){
    80.         System.out.print(name + ": ");
    81.         for (String poker : list) {
    82.             System.out.print(poker + " ");
    83.         }
    84.         System.out.println();
    85.     }
    86. }

    4.4 排序（第一种排序方式）

    1. public class App {
    2.     public static void main(String[] args) {
    3.       /*
    4.         完成控制台版的四步：
    5.           准备牌
    6.           洗牌
    7.           发牌
    8.           排序
    9. ​
    10.        */
    11. ​
    12.         //从程序的主入口开启斗地主游戏
    13.         new PokerGame();
    14.     }
    15. }
    16. ​
    17. ​
    18. public class PokerGame {
    19.     //牌盒 Map
    20.     //此时我们只要把牌跟序号产生对应关系就可以了，不需要按照序号进行排序，所以只要HashMap就可以了
    21.     static HashMap hm = new HashMap<>();
    22.     static ArrayList list = new ArrayList<>();
    23. ​
    24.     static {
    25.         String[] color = {"♦", "♣", "♥", "♠"};
    26.         String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    27. ​
    28.         //序号
    29.         int serialNumber = 1;
    30.         //细节
    31.         for (String n : number) {
    32.             //依次表示每一个数字
    33.             for (String c : color) {
    34.                 //依次表示每一个花色
    35.                 hm.put(serialNumber, c + n);
    36.                 list.add(serialNumber);
    37.                 serialNumber++;
    38.             }
    39.         }
    40. ​
    41.         hm.put(serialNumber, "小王");
    42.         list.add(serialNumber);
    43.         serialNumber++;
    44.         hm.put(serialNumber, "大王");
    45.         list.add(serialNumber);
    46. ​
    47.     }
    48. ​
    49.     public PokerGame() {
    50.         //洗牌
    51.         Collections.shuffle(list);
    52. ​
    53.         //发牌
    54.         TreeSet lord = new TreeSet<>();
    55.         TreeSet player1 = new TreeSet<>();
    56.         TreeSet player2 = new TreeSet<>();
    57.         TreeSet player3 = new TreeSet<>();
    58. ​
    59.         for (int i = 0; i < list.size(); i++) {
    60.             //i :依次表示集合中的每一个索引
    61.             //list.get(i)元素：牌的序号
    62.             int serialNumber = list.get(i);
    63. ​
    64.             if(i <= 2){
    65.                 lord.add(serialNumber);
    66.                 continue;
    67.             }
    68. ​
    69.             if(i % 3 == 0){
    70.                 player1.add(serialNumber);
    71.             }else if(i % 3 == 1){
    72.                 player2.add(serialNumber);
    73.             }else{
    74.                 player3.add(serialNumber);
    75.             }
    76.         }
    77. ​
    78. ​
    79.         //看牌
    80.         lookPoker("底牌",lord);
    81.         lookPoker("钢脑壳",player1);
    82.         lookPoker("大帅比",player2);
    83.         lookPoker("蛋筒",player3);
    84. ​
    85.     }
    86. ​
    87.     /*
    88.     * 参数一：玩家的名字
    89.     * 参数二：牌的序号
    90.     * */
    91.     public void lookPoker(String name, TreeSet ts){
    92.         System.out.print(name + ": ");
    93.         //遍历TreeSet集合得到每一个序号，再拿着序号到Map集合中去找真正的牌
    94.         for (int serialNumber : ts) {
    95.             String poker = hm.get(serialNumber);
    96.             System.out.print(poker + " ");
    97.         }
    98.         System.out.println();
    99.     }
    100. }

    4.5 排序（第二种排序方式）

    1. public class App {
    2.     public static void main(String[] args) {
    3.         new PokerGame();
    4.     }
    5. }
    6. ​
    7. ​
    8. public class PokerGame {
    9.     //牌盒
    10.     static ArrayList list = new ArrayList<>();
    11. ​
    12.     //创建一个集合，用来添加牌的价值
    13.     static HashMap hm = new HashMap<>();
    14. ​
    15.     static {
    16.         //准备牌
    17.         String[] color = {"♦", "♣", "♥", "♠"};
    18.         String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    19. ​
    20.         for (String c : color) {
    21.             for (String n : number) {
    22.                 list.add(c + n);
    23.             }
    24.         }
    25.         list.add(" 小王");
    26.         list.add(" 大王");
    27. ​
    28. ​
    29.         //指定牌的价值
    30.         //牌上的数字到Map集合中判断是否存在
    31.         //存在，获取价值
    32.         //不存在，本身的数字就是价值
    33.         hm.put("J", 11);
    34.         hm.put("Q", 12);
    35.         hm.put("K", 13);
    36.         hm.put("A", 14);
    37.         hm.put("2", 15);
    38.         hm.put("小王", 50);
    39.         hm.put("大王", 100);
    40. ​
    41. ​
    42.     }
    43. ​
    44.     public PokerGame() {
    45.         //洗牌
    46.         Collections.shuffle(list);
    47. ​
    48.         //发牌
    49.         ArrayList lord = new ArrayList<>();
    50.         ArrayList player1 = new ArrayList<>();
    51.         ArrayList player2 = new ArrayList<>();
    52.         ArrayList player3 = new ArrayList<>();
    53. ​
    54.         for (int i = 0; i < list.size(); i++) {
    55.             String poker = list.get(i);
    56.             //发底牌
    57.             if (i <= 2) {
    58.                 lord.add(poker);
    59.                 continue;
    60.             }
    61. ​
    62.             //给三个玩家轮流发牌
    63.             if (i % 3 == 0) {
    64.                 player1.add(poker);
    65.             } else if (i % 3 == 1) {
    66.                 player2.add(poker);
    67.             } else {
    68.                 player3.add(poker);
    69.             }
    70.         }
    71. ​
    72. ​
    73.         //排序
    74.         order(lord);
    75.         order(player1);
    76.         order(player2);
    77.         order(player3);
    78. ​
    79. ​
    80.         //看牌
    81.         lookPoker("底牌",lord);
    82.         lookPoker("钢脑壳",player1);
    83.         lookPoker("大帅比",player2);
    84.         lookPoker("蛋筒",player3);
    85.     }
    86. ​
    87. ​
    88.     /*
    89.      * 参数一：玩家的名字
    90.      * 参数二：每位玩家的牌
    91.      * */
    92.     public void lookPoker(String name, ArrayList list){
    93.         System.out.print(name + ": ");
    94.         for (String poker : list) {
    95.             System.out.print(poker + " ");
    96.         }
    97.         System.out.println();
    98. ​
    99.     }
    100. ​
    101. ​
    102.     //利用牌的价值进行排序
    103.     //参数：集合
    104.     //♥5 ♥3 ♥6 ♥7 ♥9
    105.     public void order(ArrayList list){
    106.         Collections.sort(list, new Comparator() {
    107.             //Array.sort （插入排序 + 二分查找）
    108.             @Override
    109.             public int compare(String o1, String o2) {
    110.                 //o1：表示当前要插入到有序序列中的牌
    111.                 //o2：表示已经在有序序列中存在的牌
    112. ​
    113.                 //负数：o1小 插入到前面
    114.                 //正数：o1大 插入到后面
    115.                 //0：o1的数字跟o2的数字是一样的，需要按照花色再次排序
    116. ​
    117.                 //1.计算o1的花色和价值   大王
    118.                 String color1 = o1.substring(0, 1);
    119.                 int value1 = getValue(o1);
    120. ​
    121.                 //2.计算o2的花色和价值
    122.                 String color2 = o2.substring(0, 1);
    123.                 int value2 = getValue(o2);
    124. ​
    125.                 //3.比较o1和o2的价值    ♥3  ♠3
    126.                 int i = value1 - value2;
    127.                 return i == 0 ? color1.compareTo(color2) : i;
    128. ​
    129.             }
    130.         });
    131.     }
    132. ​
    133.     //计算牌的价值
    134.     //参数：牌
    135.     //返回值：价值
    136.     public int getValue(String poker){//♥3
    137.         //获取牌上的数字
    138.         String number = poker.substring(1);//把这里截取出来的结果，让这个结果再Map集合中存在 “ 大王”
    139.         //拿着数字到map集合中判断是否存在
    140.         if(hm.containsKey(number)){
    141.             //存在，获取价值
    142.             return hm.get(number);
    143.         }else{
    144.             //不存在，类型转换
    145.             return Integer.parseInt(number);
    146.         }
    147.     }
    148. }
  • 相关阅读:
    idea中创建jsp项目详细步骤
    大数据开发 hadoop集群1. 概论
    PEG聚乙二醇功能上转换荧光纳米颗粒
    Baumer工业相机堡盟工业相机如何通过BGAPISDK获取相机接口数据吞吐量（C语言）
    【JVM】内存快照分析工具Jprofiler
    RGB+深度图像 语义分割paper阅读笔记（ICRA2021）
    智慧工地抽烟识别检测系统
    经常遇到的问题
    【面试系列】后端开发工程师 高频面试题及详细解答
    Flink保证exactly-once机制介绍：checkpoint及TwoPhaseCommitSinkFunction
  • 原文地址：https://blog.csdn.net/qq_69748833/article/details/132927818