java斗地主扑克 扑克牌 洗牌 发牌 Collection 集…

package com.swift.poker;

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

/*训练考核知识点：Collection接口的基本方法、

训练描述:
按照斗地主的规则，完成洗牌发牌的动作。
    具体规则：
        使用54张牌打乱顺序
        三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
        
操作步骤描述:
?准备牌：
    牌可以设计为一个ArrayList<String>,每个字符串为一张牌。
    每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
    牌由Collections类的shuffle方法进行随机排序。
?发牌：
    将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
?看牌：
    直接打印每个集合*/

public class Poker {

    public static void main(String[] args) {

        ArrayList<String> huase=new ArrayList<String>();
        huase.add("?");
        huase.add("?");
        huase.add("?");
        huase.add("方片");
        ArrayList<String> shuzi=new ArrayList<String>();
        shuzi.add("A");
        shuzi.add("2");
        shuzi.add("3");
        shuzi.add("4");
        shuzi.add("5");
        shuzi.add("6");
        shuzi.add("7");
        shuzi.add("8");
        shuzi.add("9");
        shuzi.add("10");
        shuzi.add("J");
        shuzi.add("Q");
        shuzi.add("K");
        ArrayList<String> puke=new ArrayList<String>();
        for(String hua:huase) {
            for(String shu:shuzi) {
                puke.add(hua+shu);
            }
        }
        puke.add("大王");
        puke.add("小王");
        for(String str:puke) {
            System.out.print(str+" ");
        }
        
        //随机洗牌
        Collections.shuffle(puke);
        System.out.println();
        for(String str:puke) {
            System.out.print(str+" ");
        }
        //发牌
        ArrayList<String> player1=new ArrayList<String>();
        ArrayList<String> player2=new ArrayList<String>();
        ArrayList<String> player3=new ArrayList<String>();
        ArrayList<String> dipai=new ArrayList<String>();
        for(int i=0;i<54;i++) {
            if(i<3) {
                dipai.add(puke.get(i));
            }
            else if(i%3==0) {
                player1.add(puke.get(i));
            }
            else if(i%3==1) {
                player2.add(puke.get(i));
            }
            else if(i%3==2) {
                player3.add(puke.get(i));
            }
        }
        //看牌
        look(player1);
        look(player2);
        look(player3);
        look(dipai);
    }

    private static void look(ArrayList<String> pai) {
        System.out.println();
        for(String str:pai) {
            System.out.print(str+" ");
        }
        System.out.println();
        
    }

}

package com.swift.lianxi;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/*按照斗地主的规则，完成洗牌发牌的动作
具体规则：
    1. 组装54张扑克牌
    2. 将54张牌顺序打乱
    3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
    4. 查看三人各自手中的牌（按照牌的大小排序）、底牌
?    手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

?准备牌：
    完成数字与纸牌的映射关系：
    使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。
?洗牌：
    通过数字完成洗牌发牌
?发牌：?
    将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
    存放的过程中要求数字大小与斗地主规则的大小对应。
    将代表不同纸牌的数字分配给不同的玩家与底牌。
?看牌：
    通过Map集合找到对应字符展示。
    通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示*/

public class Demo3 {

    public static void main(String[] args) {

        String[] huase = { "?", "?", "?", "?" };
        String[] paimian = { "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3" };
        // 生成扑克牌
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        for (int i = 0; i < 54; i++) {
            numbers.add(i);
        }
        Map<Integer, String> poker = new HashMap<Integer, String>();
        poker.put(0, "大王");
        poker.put(1, "小王");
        int i = 2;
        for (String pai : paimian) {
            for (String hua : huase) {
                poker.put(numbers.get(i), hua + "-" + pai);
                i++;
            }
        }
        lookMap(poker);
        // 打乱扑克牌
        Collections.shuffle(numbers);
        System.out.println("=============================");
        for (Integer n : numbers) {
            System.out.print(n + " ");
        }
        // 三人摸牌留3张底
        List<Integer> player1 = new ArrayList<Integer>();
        List<Integer> player2 = new ArrayList<Integer>();
        List<Integer> player3 = new ArrayList<Integer>();
        List<Integer> dipai = new ArrayList<Integer>();
        //这里分牌错了,把指定的 扑克分给了指定的人
/*        for (int j : numbers) {
            if(j==51||j==52||j==53) {
                dipai.add(j);
            }else {
                if (j % 3 == 0) {
                    player1.add(j);
                } else if (j % 3 == 1) {
                    player2.add(j);
                } else if (j % 3 == 2) {
                    player3.add(j);
                }
            }
        }*/
        //应该把第几号的牌给指定的人,第几号牌面洗牌后是不同的
        for (int k=0;k<numbers.size();k++) {
            if(k==51||k==52||k==53) {
                dipai.add(numbers.get(k));
            }else {
                if (k % 3 == 0) {
                    player1.add(numbers.get(k));
                } else if (k % 3 == 1) {
                    player2.add(numbers.get(k));
                } else if (k % 3 == 2) {
                    player3.add(numbers.get(k));
                }
            }
        }
        // 3名玩家和底牌排序
        Collections.sort(player1);
        Collections.sort(player2);
        Collections.sort(player3);
        System.out.println();
        System.out.println(player1);
        System.out.println(player2);
        System.out.println(player3);
        Collections.sort(dipai);
        // 看牌
        System.out.println();
        lookPai(poker, player1);
        lookPai(poker, player2);
        lookPai(poker, player3);
        lookPai(poker, dipai);

    }

    private static void lookPai(Map<Integer, String> poker, List<Integer> player1) {
        for (Integer p : player1) {
            System.out.print(poker.get(p) + " ");
        }
        System.out.println();
    }

    private static void lookMap(Map<Integer, String> poker) {
        for (Integer x : poker.keySet()) {
            System.out.print(poker.get(x) + "  ");
        }
        System.out.println();
    }

}