JAVA基础集合模拟斗地主

水深无声 2022-05-15 11:42 227阅读 0赞

### 模拟斗地主部分功能未排序 ###

> 直接把牌放在一个`ArrayList<String>`中  
> 通过Collections的shuffle洗牌

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.Random;
    
    /** * 模拟斗地主 * 部分功能 * 1、准备一幅牌（54张） * 2、洗牌（打乱牌序） * 3、发牌（三个人） * 4、留三张底牌 * 5、每个人拿到牌后，对牌进行排序 * * 未排序 */
    public class Poker { 
        public static void main(String[] args) {
    
            // 1.创建54张牌
            List<String> poker = new ArrayList<>();
    
            String[] colors = {
       "黑桃", "红心", "梅花", "方块"};
    
            String[] nums = {
       "2", "3", "4","5","6","7","8","9","10","J","Q","K","A"};
    
            // 遍历添加生成的牌到poker集合
            for (String color : colors) {
                for (String num : nums) {
                    //System.out.println(color+num);
                    String pai = color + num;  // 一张牌
                    poker.add(pai);
                }
            }
    
            // 添加大王小王
            poker.add("小王");
            poker.add("大王");
    
            // 打乱牌
            Collections.shuffle(poker);
    
            // 留底牌
            List<String> diPais = new ArrayList<>();
            // 随机找三张底牌
            Random random = new Random();
            for (int i = 0; i < 3; i++) {
                // 生成底牌索引
                int diPaiIndex = random.nextInt(poker.size());
                // 通过索引删除某一张牌，remove方法会返回删除那个索引的字符串
                String diPai = poker.remove(diPaiIndex);
                // 将返回的字符串添加到底牌集合
                diPais.add(diPai);
            }
            // 看底牌
            System.out.println("底牌：" + diPais);
    
            // 发牌
            // 创建三个人，每个人是一个集合，用来将装牌
            List<String> gaoJing = new ArrayList<>();
            List<String> longWu = new ArrayList<>();
            List<String> kyrieCao = new ArrayList<>();
    
            // 遍历发牌
            for (int i = 0; i < poker.size(); i++) {
                int mod = i % 3;    // 0 1 2 0 1 2
                String pai = poker.get(i);
                if (mod == 0) {
                    gaoJing.add(pai);
                } else if (mod == 1) {
                    longWu.add(pai);
                } else if (mod == 2) {
                    kyrieCao.add(pai);
                }
            }
            // 看牌
            System.out.println("高进：" + gaoJing);
            System.out.println("龙五：" + longWu);
            System.out.println("Cao：" + kyrieCao);
        }
    }
    // 打印结果
    底牌：[梅花3, 方块7, 黑桃2]
    高进：[梅花8, 大王, 方块K, 梅花4, 方块A, 黑桃4, 红心8, 黑桃8, 黑桃6, 小王, 红心K, 红心6, 方块3, 梅花A, 黑桃Q, 梅花Q, 黑桃K]
    龙五：[梅花2, 红心2, 方块4, 方块2, 黑桃J, 红心Q, 黑桃7, 梅花K, 梅花10, 黑桃9, 方块Q, 梅花9, 红心9, 方块8, 红心10, 方块9, 黑桃3]
    Cao：[方块6, 梅花7, 梅花J, 黑桃5, 黑桃A, 红心A, 方块5, 方块J, 红心7, 红心3, 方块10, 红心J, 红心4, 黑桃10, 红心5, 梅花6, 梅花5]

### 模拟斗地主部分功能排序 ###

> 把牌放在`HashMap<Integer, String>`中，索引当作Key  
> 把所有的Key存储`ArrayList<Integer>`中，方便洗索引  
> 通过Collections的shuffle洗牌，洗`ArrayList<Integer>`

import java.util.*;
    
    /** * 模拟斗地主 * 部分功能 * 1、准备一幅牌（54张） * 2、洗牌（打乱牌序） * 3、发牌（三个人） * 4、留三张底牌 * 5、每个人拿到牌后，对牌进行排序 * * 排序 */
    public class PokerSort { 
    
        public static void main(String[] args) {
    
            // 创建poker的map集合
            Map<Integer,String> poker = new HashMap<>();
    
            String[] colors = {
       "黑桃", "红心", "梅花", "方块"};
    
            String[] nums = {
       "2", "3", "4","5","6","7","8","9","10","J","Q","K","A"};
    
            // 数字排序
            int index = 0;
            for (String num : nums) {
                for (String color : colors) {
                    String pai = color + num;
                    poker.put(index,pai);
                    index ++;
                }
            }
    
            // 添加大王小王
            poker.put(index,"小王");
            index ++;
            poker.put(index,"大王");
    
            System.out.println("============遍历poker============");
            for (Map.Entry<Integer, String> entry :  poker.entrySet()) {
                Integer pokerIndex = entry.getKey();
                String pai = entry.getValue();
                System.out.println(pokerIndex + "..." + pai);
            }
    
            // 获取牌的索引
            Set<Integer> pokerKeys = poker.keySet();
    
            // 把set 转 list
            List<Integer> pokerIndexs = new ArrayList<>();
            for (Integer i : pokerKeys) {
                pokerIndexs.add(i);
            }
    
            // 把索引打乱
            Collections.shuffle(pokerIndexs);
            System.out.println("===========打乱牌索引==========");
            System.out.println("pokerIndexs: " + pokerIndexs);
    
            // 留底牌【前三张】
            Set<Integer> dipaiIdxs = new TreeSet<>();
            dipaiIdxs.add(pokerIndexs.remove(0));
            dipaiIdxs.add(pokerIndexs.remove(0));
            dipaiIdxs.add(pokerIndexs.remove(0));
            System.out.println("===========底牌索引===========");
            System.out.println("dipaiIdxs: " + dipaiIdxs);
    
            // 发牌
            Set<Integer> gaoJinInxs = new TreeSet<>();
            Set<Integer> longWuInxs = new TreeSet<>();
            Set<Integer> kyrieCaoInxs = new TreeSet<>();
    
            for (int i = 0; i < pokerIndexs.size(); i++) {
                // 取出扑克的索引
                int pokerIndex = pokerIndexs.get(i);
                int mod = i % 3;
                switch (mod) {
                    case 0:
                        gaoJinInxs.add(pokerIndex);
                        break;
                    case 1:
                        longWuInxs.add(pokerIndex);
                        break;
                    case 2:
                        kyrieCaoInxs.add(pokerIndex);
                        break;
                }
            }
    
            // 打印扑克的索引
            System.out.println("高进: " + gaoJinInxs);
            System.out.println("龙五: " + longWuInxs);
            System.out.println("Cao: " + kyrieCaoInxs);
    
            // 看牌
            lookPoker("底牌", poker, dipaiIdxs);
            lookPoker("高进", poker, gaoJinInxs);
            lookPoker("龙五", poker, longWuInxs);
            lookPoker("Cao", poker, kyrieCaoInxs);
        }
    
        /** * 看牌 * @param name 玩家姓名 * @param poker 完整的扑克牌 * @param playerPokerIndexs 玩家扑克牌的索引 */
        public static void lookPoker(String name, Map<Integer,String> poker, Set<Integer> playerPokerIndexs) {
            // 真实的扑克集合
            List<String> pokerValues = new ArrayList<>();
            // 遍历玩家的扑克牌索引
            for (Integer key : playerPokerIndexs) {
                pokerValues.add(poker.get(key));
            }
            System.out.println(name + " : " + pokerValues);
        }
    }
    // 打印结果
    底牌 : [黑桃7, 红心10, 红心J]
    高进 : [红心2, 方块2, 红心3, 红心4, 梅花5, 红心7, 梅花7, 方块9, 黑桃10, 梅花10, 方块J, 红心Q, 梅花K, 方块K, 黑桃A, 梅花A, 小王]
    龙五 : [黑桃2, 黑桃3, 方块3, 梅花4, 黑桃6, 梅花6, 方块7, 红心8, 红心9, 梅花9, 方块10, 梅花J, 梅花Q, 方块Q, 红心K, 红心A, 方块A]
    Cao : [梅花2, 梅花3, 黑桃4, 方块4, 黑桃5, 红心5, 方块5, 红心6, 方块6, 黑桃8, 梅花8, 方块8, 黑桃9, 黑桃J, 黑桃Q, 黑桃K, 大王]