JAVA基础集合模拟斗地主

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

直接把牌放在一个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, 大王]