集合（模拟斗地主发牌）

思路：
* A:创建一个HashMap集合
* B:创建一个ArrayList集合
* C:创建花色数组和点数数组
* D:从0开始往HashMap里面存储编号，并存储对应的牌
* 同时往ArrayList里面存储编号即可。
* E:洗牌(洗的是编号)
* F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
* G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)

输出牌---无序版

package Day18;

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

public class PoKe {
    public static void main(String[] args) {
        //创建牌盒---集合
        ArrayList array = new ArrayList();

        //装牌

        //定义一个花色数组
        String [] colors = {"?","?","?","?"};
        //定义一个点数的数组
        String [] number = {"A","2","3","4","5","6","7","8","9","J","Q","K"};
        //将牌装入集合array中
        //增强for进行循环遍历获取花色字符数组中的每个花色
        for(String a : colors){
            //遍历点数字符数组获取每个点数
            for(String b:number){
                //对获取的每个花色和点数进行字符的拼接---并将其添加到集合array中
                //字符拼接使用String类中的public String concat(String str)将指定字符串连接到此字符串的结尾。
                array.add(a.concat(b));
            }
        }
        array.add("小王");
        array.add("大王");
        //输出查看字符中的集合---是否添加上元素
        //System.out.println(array);
//        for(String t: array){
//            System.out.println(t);
//        }

        //洗牌
        //使用Collections中任意置换的方法实现其集合元素的混乱
        //public static void shuffle(List<?> list)使用默认随机源对指定列表进行置换。
        // 所有置换发生的可能性都是大致相等的。
        Collections.shuffle(array);
        //输出查看集合是否混乱
        //System.out.println(array);


        //看牌
        //斗地主三人打牌
        //首先创建三个集合用来存储每个人的牌---还有一个集合存储最后三张底牌
        ArrayList zhao = new ArrayList();
        ArrayList zhu = new ArrayList();
        ArrayList wang = new ArrayList();
        ArrayList dipai = new ArrayList();

        //进行分发牌
        //首先遍历array集合
        for(int x=0;x){
            //进行底牌的判断---只留最后三张---放在遍历循环的开始，以防添加到别的集合
            if(x>= array.size()-3){
                //添加最后三张底牌
                dipai.add(array.get(x));
            }
            //进行顺序发牌
            if(x%3==0){
                //三人发牌---这是第一个拿牌的
                //如果遍历的array集合的索引的取余是零--就将此处array的索引值添加到zhao集合中
                zhao.add(array.get(x));
            }else if(x%3==1){
                //三人发牌--这是第二个拿牌的
                zhu.add(array.get(x));
            }else if(x%3==2){
                //三人发牌--这是第三个拿牌的
                wang.add(array.get(x));
            }
        }

        //查看牌---此时的查看牌定义一个功能方法--查看任意一个调用功能方法即可
        kanpai("赵同刚",zhao);
        kanpai("朱庆娜",zhu);
        kanpai("王丽丽",wang);
        kanpai("底牌",dipai);
    }

    //两个明确
    //返回值类型----void(任意型)  参数列表--A:给出拿牌人的姓名--B：给出拿牌的集合
    public static void kanpai(String name,ArrayList m){
        //进行格式的调整
        System.out.print(name+":");
        //遍历输出集合中的每一个元素
        for (String e : m){
            System.out.print(e+",");
        }
        //每个人的牌在输出时进行换行，以方便查看
        System.out.println();

    }




}

有序版

package Day18;



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

/*
* 思路：
 *         A:创建一个HashMap集合
 *         B:创建一个ArrayList集合
 *         C:创建花色数组和点数数组
 *         D:从0开始往HashMap里面存储编号，并存储对应的牌
 *        同时往ArrayList里面存储编号即可。
 *      E:洗牌(洗的是编号)
 *      F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
 *      G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
* */
public class PoKe1 {
    public static void main(String[] args) {
        //牌盒
        //创建一个HashMap集合---存储编号和对应的牌
        HashMap hm = new HashMap();

        //创建一个ArrayList集合---存储编号
        ArrayList Al = new ArrayList();

        //装牌
        //创建花色字符数组和点数字符数组
        String [] color = {"?","?","?","?"};
        String [] number = {"A","2","3","4","5","6","7","8","9","J","Q","K"};

        //首先定义一个记录编号的值
        int index = 0;

        //将花色字符和点数数组进行拼接
            //获取遍历点数字符数组中的每个字符
             for(String nb:number){
                 //遍历获花色数字符数组中的每个点数
                 for(String cr:color){
                     //将获取的花色字符与点数字符进行拼接
                     //字符拼接使用String类中的public String concat(String str)将指定字符串连接到此字符串的结尾。
                     String PJ = cr.concat(nb);
                     //--并添加到HashMap集合中----值--牌
                     hm.put(index,PJ);
                     //同时向ArrayList添加编号
                     Al.add(index);
                     index++;
                 }

             }
         //上述方法做完仍还有大小王没有添加---进行添加大小王
        hm.put(index,"小王");
        Al.add(index);
        index++;
        hm.put(index,"大王");
        Al.add(index);

        //洗牌--对编号进行洗牌
        Collections.shuffle(Al);


        //看牌
        //发牌
        //首先创建三个集合用来存储每个人的牌---还有一个集合存储最后三张底牌
        //创建TreeSet集合进行接受有序排序---发牌发的也是编号--斗地主三人一个底牌
        TreeSet FP1 = new TreeSet();
        TreeSet FP2 = new TreeSet();
        TreeSet FP3 = new TreeSet();
        TreeSet FP4 = new TreeSet();
        //遍历ArrayList置换后的集合---利用获取的编号调用ArrayList中get（）的方法来获取集合元素
        // --并添加添加到TerrSet集合中
        for(int x=0;x){
            //底牌  //进行底牌的判断---只留最后三张---放在遍历循环的开始，以防添加到别的集合
            if(x>Al.size()-3){
                FP4.add(Al.get(x));
                //三人发牌---这是第一个拿牌的
            }else if(x%3==0){
                FP1.add(Al.get(x));
                //三人发牌--这是第二个拿牌的
            }else if(x%3==1){
                FP2.add(Al.get(x));
            }else if (x%3==2){
                //三人发牌--这是第三个拿牌的
                FP3.add(Al.get(x));
            }
        }

        //已经给玩家发牌完--现在进行看牌
        //定义功能方法---方便调用查看每个人的牌
        show("赵同刚",FP1,hm);
        show("朱庆娜",FP2,hm);
        show("王丽丽",FP3,hm);
        show("底牌",FP4,hm);


    }
    //两个明确
    //参数类型  --void  参数列表  A：传入玩家的姓名  B：传入玩家的牌(编号集合)  C：对应的牌(牌值集合)
    public static void show(String name,TreeSet FP,HashMap hm ){
        System.out.print(name+":");
        //首先遍历编号集合
        for(Integer e :FP){
            //利用遍历的集合编号输出---对应牌的(牌值集合)
            String tt = hm.get(e);
            System.out.print(tt+",");
        }
        System.out.println();
    }

}

标准有序版

public class PokerDemo {
    public static void main(String[] args) {
        // 创建一个HashMap集合
        HashMap hm = new HashMap();

        // 创建一个ArrayList集合
        ArrayList array = new ArrayList();

        // 创建花色数组和点数数组
        // 定义一个花色数组
        String[] colors = { "?", "?", "?", "?" };
        // 定义一个点数数组
        String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
                "K", "A", "2", };

        // 从0开始往HashMap里面存储编号，并存储对应的牌,同时往ArrayList里面存储编号即可。
        int index = 0;

        for (String number : numbers) {
            for (String color : colors) {
                String poker = color.concat(number);
                hm.put(index, poker);
                array.add(index);
                index++;
            }
        }
        hm.put(index, "小王");
        array.add(index);
        index++;
        hm.put(index, "大王");
        array.add(index);

        // 洗牌(洗的是编号)
        Collections.shuffle(array);

        // 发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
        TreeSet fengQingYang = new TreeSet();
        TreeSet linQingXia = new TreeSet();
        TreeSet liuYi = new TreeSet();
        TreeSet diPai = new TreeSet();

        for (int x = 0; x < array.size(); x++) {
            if (x >= array.size() - 3) {
                diPai.add(array.get(x));
            } else if (x % 3 == 0) {
                fengQingYang.add(array.get(x));
            } else if (x % 3 == 1) {
                linQingXia.add(array.get(x));
            } else if (x % 3 == 2) {
                liuYi.add(array.get(x));
            }
        }

        // 看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
        lookPoker("风清扬", fengQingYang, hm);
        lookPoker("林青霞", linQingXia, hm);
        lookPoker("刘意", liuYi, hm);
        lookPoker("底牌", diPai, hm);
    }

    // 写看牌的功能
    public static void lookPoker(String name, TreeSet ts,
            HashMap hm) {
        System.out.print(name + "的牌是：");
        for (Integer key : ts) {
            String value = hm.get(key);
            System.out.print(value + " ");
        }
        System.out.println();
    }
}