Java案例——斗地主简单操作——洗牌·发牌·看牌

需求：实现斗地主的洗牌、发牌、看牌

分析：

1.创建一个牌库，用于存放54张牌，使用ArrayList来实现

2.创建两个数组 1.存放牌的颜色分类colors,2存放具体牌

3.将牌放入牌库

4.洗牌，使用Collections.shuffle()方法实现

5.定义发牌方法

6.定义看牌方法

代码：

/*
* 实现斗地主的简单操作 洗牌、发牌、看牌
* */
public class FightAgainstLandlords {
    public static void main(String[] args) {
        //创建一个牌库，用于存放54张牌，使用ArrayList来实现
        ArrayListal=new ArrayList();
        //创建两个数组 1.存放牌的颜色分类colors,2存放具体牌
        String [] colors={"?","?","?","?"};
        String [] poker={"2","3","4","5","6","7","8","9","10","J","Q","K"};
        //将牌放入牌库,并洗牌
        for (String color:colors){
            for (String pokers:poker){
                al.add(color+pokers);
            }
        }
        //加入大王小王
        al.add("大王");
        al.add("小王");
        Collections.shuffle(al);
        //定义三人每个人的牌库
        ArrayList landlord=new ArrayList();
        ArrayList farmerone=new ArrayList();
        ArrayList farmertwo=new ArrayList();
        ArrayListhand=new ArrayList();
        //发牌
        for (int i=0;i            //留出底牌并指定发牌规则
            if (i>=al.size()-3){
                String handpoker = al.get(i);
                hand.add(handpoker);
            }else if(i%3==0){
                farmerone.add(al.get(i));
?
            }else if (i%3==1){
                farmertwo.add(al.get(i));
            }else if (i%3==2){
                landlord.add(al.get(i));
            }
?
        }
        //看牌
        lookPoker("农民一",farmerone);
        lookPoker("农民二",farmertwo);
        lookPoker("地主",landlord);
        lookPoker("底牌\t",hand);
    }
    //定义看牌方法
    public static void lookPoker(String name,ArrayListarray){
        //看牌也就是遍历
        System.out.print(name+"的牌是");
        for (String poker:array){
            System.out.print(poker+" ");
        }
        System.out.println();
?
    }
?
}

升级版

使用集合实现并排序

分析：

1.创建HashMap集合，作为牌库，键从0-53作为编号代表共54张牌，值存储具体的每张牌

2.创建ArrayList同步存储编号

3.创建colors\poker数组同上

4.从0开始往HashMap中存入编号以及编号对应的牌，ArrayList同步编号

5.洗牌，洗ArrayList里面的编号

6.发牌为了保证编号是有顺序的，使用TreeSet进行接收

升级版代码：

public class FightAgainstLandlordsUp {
    public static void main(String[] args) {
        //创建HashMap集合，作为牌库，键从0-53作为编号代表共54张牌，值存储具体的每张牌
        HashMap hm = new HashMap();
        //创建ArrayList同步存储编号
        ArrayList al = new ArrayList();
        //创建colors\poker数组同上
        String[] colors = {"?", "?", "?", "?"};
        String[] poker = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
        //从0开始往HashMap中存入编号以及编号对应的牌，ArrayList同步编号
        int index = 0;//声明一个变量作为编号
        for (String color : colors) {
            for (String pokers : poker) {
                hm.put(index, color + pokers);
                al.add(index);
                index++;
            }
        }
        //加入大小王
        hm.put(index, "大王");
        al.add(index);
        index++;
        hm.put(index, "小王");
        al.add(index);
        //洗牌，洗ArrayList里面的编号
        Collections.shuffle(al);
        //发牌为了保证编号是有顺序的，使用TreeSet进行接收
        TreeSet landlord = new TreeSet();
        TreeSet farmerone = new TreeSet();
        TreeSet farmertwo = new TreeSet();
        TreeSet hand = new TreeSet();
        //发牌，发的也是编号
        for (int i = 0; i < al.size(); i++) {
            ////留出底牌并指定发牌规则
            if (i >= al.size() - 3) {
                hand.add(al.get(i));
            } else if (i % 3 == 1) {
                landlord.add(al.get(i));
            } else if (i % 3 == 2) {
                farmerone.add(al.get(i));
            } else if (i % 3 == 0) {
                farmertwo.add(al.get(i));
            }
        }
        lookPoker("地主", landlord, hm);
        lookPoker("农民一", farmerone, hm);
        lookPoker("农民二", farmertwo, hm);
        lookPoker("底牌", hand, hm);
?
    }
?
    //定义看牌方法
    public static void lookPoker(String name, TreeSet set, HashMap hm) {
        System.out.print(name + "的牌是：");
        for (int x : set) {
            String pk = hm.get(x);
            System.out.print(pk + " ");
?
        }
        System.out.println();
    }
}