斗地主随机发牌实现

需求:
通过程序实现斗地主过程中的洗牌，发牌和看牌

思路:

1. 创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
2. 往牌盒里面装牌
3. 洗牌，也就是把牌打撒，用Collections的shuffle()方法实现
4. 发牌，也就是遍历集合，给三个玩家发牌
5. 看牌，也就是三个玩家分别遍历自己的牌

代码：

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

public class Demo1 {
    public static void main(String[] args) {
        // 创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
        ArrayList<String> pokers = new ArrayList<>();

        // 因为牌是由花色和字符组成
        // 定义一个花色数组
        String[] colors = {"♦", "♠", "♣", "♥"};
        // 定义一个点数数组
        String[] nums = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        // 使用循环进行拼接
        // 往牌盒里面装牌
        for (String color : colors) {
            for (String num : nums) {
                // 拼接并装入ArrayList
                pokers.add((color + num));
            }
        }
        // 装入大小王
        pokers.add("大王");
        pokers.add("小王");

        // 洗牌，用Collections的shuffle()方法实现
        Collections.shuffle(pokers);

        // 发牌，也就是遍历集合，给三个玩家发牌
        // 也用ArrayList存起来
        ArrayList<String> player1 = new ArrayList<String>();
        ArrayList<String> player2 = new ArrayList<String>();
        ArrayList<String> player3 = new ArrayList<String>();
        // 地主底牌
        ArrayList<String> list = new ArrayList<String>();

        for (int i = 0; i < pokers.size(); i++) {
            // 将牌遍历出来
            String poker = pokers.get(i);
            //  最后三张给底牌
            if (i >= pokers.size() - 3) {
                list.add(poker);
            } else if ((i % 3) == 0) {
                // 第一个玩家的牌
                player1.add(poker);
            } else if ((i % 3) == 1) {
                // 第二个玩家的牌
                player2.add(poker);
            } else {
                // 第三个玩家的牌
                player3.add(poker);
            }
        }

        // 看牌，也就是三个玩家分别遍历自己的牌
        lookPokers("玩家1", player1);
        lookPokers("玩家2", player2);
        lookPokers("玩家3", player3);
        lookPokers("地主底牌", list);
    }

    // 定义一个看牌的方法
    public static void lookPokers(String name, ArrayList<String> player) {
        System.out.println(name + "的牌是：");
        // 遍历
        for (String poker : player) {
            System.out.print(poker + "\t");
        }
        System.out.println();
        System.out.println("---------------------------------------------------------------------");
    }
}

升级版：

看牌时进行排序

思路：

1. 创建HashMap，键是编号,值是牌
2. 创建ArrayList,存储编号
3. 创建花色数组和点数数组
4. 从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
5. 洗牌(洗的是编号)，用Collections的shuffle()方法实现
6. 发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收
7. 定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌）

代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class Demo2 {
    public static void main(String[] args) {
        // 创建HashMap，键是编号,值是牌
        HashMap<Integer, String> pokers = new HashMap<>();
        // 创建Arraylist,存储编号
        ArrayList<Integer> arrayList = new ArrayList<>();
        // 创建花色数组和点数数组
        // 定义一个花色数组
        String[] colors = {"♦", "♠", "♣", "♥"};
        // 定义一个点数数组
        String[] nums = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};

        // 使用循环进行拼接
        // 定义一个index
        int index = 0;
        for (String color : colors) {
            for (String num : nums) {
                String poker = (color + num);
                // 从0开始往HashMap里面存储编号，并存储对应的牌。
                pokers.put(index, (color + num));
                // 同时往ArrayList里面存储编号
                arrayList.add(index);
                ++index;
            }
        }
        // 大小王
        pokers.put(index, "大王");
        arrayList.add(index);
        ++index;
        pokers.put(index, "小王");
        arrayList.add(index);

        // 洗牌(洗的是编号)，用Collections的shuffle(方法实现
        Collections.shuffle(arrayList);
        // 发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)
        TreeSet<Integer> p1 = new TreeSet<>();
        TreeSet<Integer> p2 = new TreeSet<>();
        TreeSet<Integer> p3 = new TreeSet<>();
        TreeSet<Integer> dp = new TreeSet<>();

        for (int i = 0; i < arrayList.size(); i++) {
            int x = arrayList.get(i);
            if (i >= arrayList.size() - 3) {
                dp.add(x);
            } else if (i % 3 == 0) {
                p1.add(x);
            } else if (i % 3 == 1) {
                p2.add(x);
            } else {
                p3.add(x);
            }
        }

        //  调用自定义看牌方法
        lookPokers("玩家1", p1, pokers);
        lookPokers("玩家2", p2, pokers);
        lookPokers("玩家3", p3, pokers);
        lookPokers("地主底牌", dp, pokers);
    }

    // 定义方法看牌(遍历TreeSet集合，获取编号，到HashNap集合找对应的牌）
    public static void lookPokers(String name, TreeSet<Integer> player, HashMap<Integer, String> pokers) {
        System.out.println(name + "的牌是：");
        // 遍历TreeSet获取编号
        for (int key : player) {
            // 到HashNap集合找对应的牌
            String poker = pokers.get(key);
            System.out.print(poker + "\t");
        }
        System.out.println();
    }
}