斗地主游戏(Java版)简单逻辑实现之洗牌，发牌

一. List集合实现

1. 规则介绍

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

具体规则：

使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌，抢地主的人可以得到那最后的三张底牌。

2. 逻辑分析

1. 准备牌：

将54张牌，存储到一个集合当中

特殊牌：大鬼，小鬼

其他52张牌：

• 定义一个数组 / 集合，存储4种花色：♠，♥(红)，♣，♦(红)
• 定义一个数组 / 集合，存储13个序号： 2,3,4,5,6,7,8,9,10,J,Q,K,A

循环嵌套遍历两个数组 / 集合，组装52张牌
♠2,♠3,♠4…♠A； ♥2,♥3,♥4…♥A； …

2. 洗牌：

使用集合工具类Collections的方法
static void shuffle(List<?> list) ：使用指定的随机源对指定列表进行置换。
可以随机的打乱集合中元素的顺序

3. 发牌

要求：一人17张牌，剩余3张作为底牌，一人一张轮流发牌： 集合中的索引(0-53)%3

实现方式：

• 定义4个集合，分别存储3个玩家的牌和底牌
• 利用索引对3取余，会产生3个值(0,1,2)，如果取余的结果为0就将索引对应的内容赋给玩家1，其他的同理，结果为1赋给玩家2，结果为2赋给玩家3。索引的值大于等于51的话 ，将索引内对应的内容赋给底牌。

4. 看牌：

直接打印集合，遍历存储玩家和底牌的集合

代码实现：

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

	public class LandlordsDemo {
	    public static void main(String[] args) {
	        // 准备牌
	        ArrayList<String> colorList = new ArrayList<>();  // 存储花色
	        colorList.add("♠");
	        colorList.add("♦");
	        colorList.add("♣");
	        colorList.add("♠");
	
	        // 存储数字
	        ArrayList<String> numberList = new ArrayList<>();
	        for (int i = 2; i <= 10; i++) {
	            numberList.add(i+"");
	        }
	        numberList.add("J");
	        numberList.add("Q");
	        numberList.add("K");
	        numberList.add("A");
	
	
	        // 存储牌面
	        ArrayList<String> poker = new ArrayList<>();
	        // 增强for循环赋值
	        for(String colors : colorList) {
	            for (String numbers : numberList) {
	                poker.add(colors + numbers);
	            }
	        }
	        poker.add("☠");   // 大王
	        poker.add("♜");  // 小王
	        System.out.println(poker);
	
	
	        // 洗牌
	        Collections.shuffle(poker);
	        System.out.println(poker);
	
	        // 发牌
	        ArrayList<String> playerOne = new ArrayList<>();
	        ArrayList<String> playerTwo = new ArrayList<>();
	        ArrayList<String> playerThree = new ArrayList<>();
	        ArrayList<String> dipai = new ArrayList<>();
	
	        for (int i = 0; i < poker.size(); i++) {
	            String card = poker.get(i);
	            if(i >= 51) {
	                dipai.add(card);
	            } else if (i % 3 == 0) {
	                playerOne.add(card);
	            } else if (i % 3 == 1) {
	                playerTwo.add(card);
	            } else if (i % 3 == 2) {
	                playerThree.add(card);
	            }
	        }
	
	        // 看牌
	        System.out.println("路飞：" + playerOne);
	        System.out.println("索隆：" + playerTwo);
	        System.out.println("山治：" + playerThree);
	        System.out.println("底牌：" + dipai);
	    }
	}

运行结果：

路飞：[♠9, ♠Q, ♠J, ♠3, ♣8, ♠9, ♦5, ♠7, ♣10, ♠7, ♦2, ♠3, ♠J, ♠6, ♠8, ♠2, ♣6]
索隆：[♠K, ♠A, ♦7, ♣7, 小鬼, ♠2, ♦9, ♣4, ♠4, ♠Q, ♣3, ♣J, ♣9, ♣K, ♣A, ♦A, ♠8]
山治：[♦3, ♦4, ♣2, ♦8, ♦Q, ♦10, ♠10, ♣Q, ♦6, ♣5, ♠4, ♠A, ♠10, ♦K, ♠5, ♦J, ♠K]
底牌：[♠6, ♠5, 大鬼]

二. Map集合实现

2.1. 具体规则：

1. 组装54张扑克牌将
2. 54张牌顺序打乱
3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
4. 查看三人各自手中的牌（按照牌的大小排序）、底牌

规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

2.2. 案例需求分析

1. 准备牌：

   完成数字与纸牌的映射关系：

   使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。

2. 洗牌：

   通过数字完成洗牌发牌

3. 发牌：

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

   存放的过程中要求数字大小与斗地主规则的大小对应。

   将代表不同纸牌的数字分配给不同的玩家与底牌。

4. 看牌：

   通过Map集合找到对应字符展示。

   通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。
   
   代码实现：

   public class Poker {
       public static void main(String[] args) {
           /*
            * 1组装54张扑克牌
            */
           // 1.1 创建Map集合存储
           HashMap<Integer, String> pokerMap = new HashMap<Integer, String>();
           // 1.2 创建花色集合与数字集合
           ArrayList<String> colors = new ArrayList<String>();
           ArrayList<String> numbers = new ArrayList<String>();
   
           // 1.3 存储花色与数字
           Collections.addAll(colors, "♦", "♣", "♥", "♠");
           Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
           // 设置存储编号变量
           int count = 0;
           pokerMap.put(count++, "大王");
           pokerMap.put(count++, "小王");
           // 1.4 创建牌存储到map集合中
           for (String number : numbers) {
               for (String color : colors) {
                   String card = color + number;
                   pokerMap.put(count++, card);
               }
           }
           /*
            * 2 将54张牌顺序打乱
            */
           // 取出编号集合
           Set<Integer> numberSet = pokerMap.keySet();
           // 因为要将编号打乱顺序，所以应该先进行转换到 list集合中
           ArrayList<Integer> numberList = new ArrayList<Integer>();
           numberList.addAll(numberSet);
   
           // 打乱顺序
           //static void shuffle(List<?> list)  使用默认随机源对指定列表进行置换。
           Collections.shuffle(numberList);
   
           // 3 完成三个玩家交替摸牌，每人17张牌，最后三张留作底牌
           // 3.1 发牌的编号
           // 创建三个玩家编号集合和一个底牌编号集合
           ArrayList<Integer> noP1 = new ArrayList<Integer>();
           ArrayList<Integer> noP2 = new ArrayList<Integer>();
           ArrayList<Integer> noP3 = new ArrayList<Integer>();
           ArrayList<Integer> dipaiNo = new ArrayList<Integer>();
   
           // 3.2发牌的编号
           for (int i = 0; i < numberList.size(); i++) {
               // 获取该编号
               Integer no = numberList.get(i);
               // 发牌
               // 留出底牌
               if (i >= 51) {
                   dipaiNo.add(no);
               } else {
                   if (i % 3 == 0) {
                       noP1.add(no);
                   } else if (i % 3 == 1) {
                       noP2.add(no);
                   } else {
                       noP3.add(no);
                   }
               }
           }
   
           // 4 查看三人各自手中的牌（按照牌的大小排序）、底牌
           // 4.1 对手中编号进行排序
           Collections.sort(noP1);
           Collections.sort(noP2);
           Collections.sort(noP3);
           Collections.sort(dipaiNo);
   
           // 4.2 进行牌面的转换
           // 创建三个玩家牌面集合以及底牌牌面集合
           ArrayList<String> player1 = new ArrayList<String>();
           ArrayList<String> player2 = new ArrayList<String>();
           ArrayList<String> player3 = new ArrayList<String>();
           ArrayList<String> dipai = new ArrayList<String>();
   
           // 4.3转换
           for (Integer i : noP1) {
               // 4.4 根据编号找到牌面pokerMap
               String card = pokerMap.get(i);
               // 添加到对应的牌面集合中
               player1.add(card);
           }
   
           for (Integer i : noP2) {
               String card = pokerMap.get(i);
               player2.add(card);
           }
           for (Integer i : noP3) {
               String card = pokerMap.get(i);
               player3.add(card);
           }
           for (Integer i : dipaiNo) {
               String card = pokerMap.get(i);
               dipai.add(card);
           }
   
           //4.5 查看
           System.out.println("路飞："+player1);
           System.out.println("山治："+player2);
           System.out.println("索隆："+player3);
           System.out.println("底牌："+dipai);
       }
   }
   

运行结果：

令狐冲：[♦2, ♦K, ♣Q, ♠Q, ♦J, ♣J, ♥J, ♠J, ♣10, ♦9, ♣9, ♣8, ♠8, ♥7, ♥6, ♠4, ♠3]
石破天：[♠2, ♦A, ♥A, ♥K, ♠K, ♦Q, ♥10, ♠9, ♦8, ♠7, ♦6, ♠6, ♦5, ♣5, ♠5, ♦4, ♥4]
鸠摩智：[小王, ♣2, ♥2, ♣A, ♠A, ♣K, ♥Q, ♦10, ♠10, ♥9, ♥8, ♦7, ♣7, ♣6, ♣4, ♦3, ♥3]
底牌：[大王, ♥5, ♣3]